I think the latter would work using "unsafe" code?  However, if you want
to stick to "safe" C# and a pointer isn't allowed, I think you would
have to allow the struct to be boxed, and use "object" as the type for
the field.

That said, I would suggest that I think if you're dealing with a type
where you feel you need a reference to the type, then the type itself
should be a reference type, not a value type.  That means making it a
class instead of a struct.

You didn't ask, but with respect to your specific example, I have a
couple of other things to point out:

    * There is already a nice generic Stack<> class in .NET.  So your
effort might be useful as a learning exercise (it's certainly raised at
least one interesting learning point here :) ), but do keep in mind the
availability of other options when writing "real" code.

    * A stack implementation in general isn't necessarily implemented
as a linked list as you appear to be trying to do here.  In fact I would
guess that most implementations are _not_ as a linked list.  I'm pretty
sure the generic Stack<> class, for example, uses an array to store the
stack elements, and I'd guess that's a fairly common implementation.

Storing the stack in array, you completely avoid any issues with respect
to having one element refer to another; they are organized simply by
virtue of their order in the array.  In fact, if you implement the stack
as a generic class, you can simply make the array contain directly the
elements of the stack, just as the existing Stack<> class does, which
allows you to avoid boxing of value types as long as the stack contains
only elements of the same type.

Pete