Question: I know that struct is a value type , that means it defined on stack .

But I can do A a = new A(); (A my struct of course). and it defined on heap , and only the reference variable is on stack.

Can you explain me this one please .

Answer: 
Where a local variable is stored is an implementation detail.  

Simple local variables are usually stored in the CPU-registers and/or the stack.

If they are captured in a closure they'll be rewritten into members in a heap allocated object. That's because the lamda might outlive it's creating functions, and thus the variables it uses must be able to live long enough too.

Unlike in C++ in C# the **`new` does not imply a heap allocation**. It's just the syntax for calling a constructor.

And calling `new` on a value-type doesn't have the semantics of a placement new either. It has the semantics of constructing an instance *somewhere* and then copying it into the target variable.

In my mental model there are two types of storage:

1. Local storage that can't outlive the return of the function. This includes stack and registers.
2. Global storage that lives until it isn't referenced anymore. This is usually the heap. But in run-times that do escape analysis it might be put on the stack if the runtime proves that no references will survive the function.

Your example falls into the first kind of storage since you use a value type.
The original assumption that value types live "on the stack" is not correct. However, **[The Truth About Value Types](http://blogs.msdn.com/b/ericlippert/archive/2010/09/30/the-truth-about-value-types.aspx)** has been revealed by Eric Lippert:

> 
> 1. It is usually stated *incorrectly*: the statement should be "value types *can* be stored on the stack", instead of the more common "value types are always stored on the stack".
> 2. It is almost always *irrelevant*. We've worked hard to make a managed environment where the distinctions between different kinds of storage are hidden from the user. Unlike some languages, in which you must know whether a particular storage is on the stack or the heap for correctness reasons.
> 3. It is incomplete. What about *references*? References are neither *value types* nor *instances of reference types*, but they are values. They've got to be stored somewhere. Do they go on the stack or the heap? Why does no one ever talk about them? Just because they don't have a type in the C# type system is no reason to ignore them.
> 
> 
>