I was of the impression that in C#, struct elements are allocated on the stack and thus disappear when returning from a method in which they were created. But what happens if I place the struct-values in a list and return that? The elements survives. Are struct instances sometimes allocated on the heap?
internal struct Stru
{
public int i;
}
internal class StruTry
{
public List<Stru> Get(int max)
{
var l = new List<Stru>();
for (int i = 0; i < max; i++)
l.Add(new Stru {i=i});
return l;
}
}
code printing 0, 1, 2
[Test]
public void T()
{
var ll = new StruTry().Get(3);
foreach (var stru in ll)
Console.WriteLine("* "+ stru.i);
}
First, read this post from Eric Lippert on The Stack is an Implementation Detail. Follow it with The Truth about Value Types.
As for your specific question
Are struct instances sometimes allocated on the heap?
Yes, they are sometimes allocated on the heap. There are lots of examples of when they could be allocated on the heap. If they are boxed, or if they are fields in a class, or if they are elements of an array, or if they are the value of a variable of value type that has been closed over, etc.
But what happens if I place the struct-values in a list and return that? The elements survives.
You're thinking about this the right way, and this is one of the salient points on where a value type might be allocated. See the second post that I referred to on The Truth About Value Types for more details. But just keep The Stack is an Implementation Detail in mind. The key takeaway is that you really don't need to concern yourself with this stuff. You should be concerned with the semantic difference between value types and reference types.
Structs are like ints. If you have a local int, it will generally be on the stack, if you have a list of ints, they are stored directly in the list's internal array, which is on the heap. Structs behave the same way.
But what happens if I place the struct-values in a list and return that? The elements survives.
Technically the values added to the 'List' are not the same values, they are value based copies. If, for example, you modify the original, those changes will not be carried to the copy in the list. Also, 'List' returns a copy of the value at the indicated index. This means if the struct is mutable and you modify the value returned from the 'List', then the value in the List<t> will remain unchanged. This is not the case with arrays, as the array index provides access to the actual variable.
All types can sometime be allocated on the heap. Besides which, heap/stack is an implementation detail of the CLR and not in the C# spec, so you shouldn't ever rely on such things. See here for a good blog post on this subject.
From what I remember...
The location of value types depends on where they are declared. Method variables are allocated, stored on the stack and removed after execution of the method in the stack frame. Value types declared as part of a reference type are stored on the heap within the structure of the enclosing type.
Let me know if I am wrong!
A storage location (variable, field, parameter, array slot, etc.) of struct type holds the struct's public and private fields within it. If that storage location is on the stack, the struct's fields will be on the stack. If it is within another class or struct, then the struct's fields will be stored as part of that other class or struct instance.
A storage location of class type holds a reference to a complete class object which is always either (1) stored somewhere completely separate from the storage location holding a reference, or (2) the class object of which that storage location is a field.
