Managed C++/CLI

In response to your questions:

1) 
The C# version is creating the struct on the stack.  Turns out newobj 
instruction can be used to create value types on the stack.  I verified 
this from the CIL spec (http://msdn.microsoft.com/net/ecma/ , see the link 
for CLI Partition III , which documents the CIL instruction set), and by 
writing a small MC++ sample that successfully consumes a value type 
returned from C# in this manner.

2)
Our team has entered a suggestion to see if we can generate more efficient 
CIL for the sample you provided.

-- 
Andrew Brown, Visual C++ Team
This posting is provided AS IS with no warranties, and confers no rights.

#include "stdafx.h"

#using <mscorlib.dll>
#include <tchar.h>

using namespace System;

__nogc struct StdHello
{
	int nSomething;
};

__value struct MCHello
{
	StdHello member;
};

// This is the entry point for this application
int _tmain(void)
{
    // TODO: Please replace the sample code below with your own.
    Console::WriteLine(S"Hello World");

	MCHello hello;
	hello.member.nSomething = 2003227;

	Console::WriteLine(__box(hello.member.nSomething));

    return 0;
}

public __gc class Hello : public System::IDisposable 
{
public:
	Hello(void)
	{
	}

	virtual ~Hello(void)
	{
		Dispose(false);
	}

	////////////////////////////////////////////////////////////////////////////
	// The System::IDisposable interface implementations

	void Dispose()
	{
		Dispose(true);
	}

protected:
	void Dispose(bool disposing)
	{
	    // Normally clean up here....  

		if (disposing)
		{
			System::GC::SuppressFinalize(this);
		}
	}

};

<br />
public __gc class B : public IDisposable<br />
{<br />
public:<br />
    virtual ~B() <br />
    { <br />
        Dispose(false); <br />
    }<br />
<br />
    virtual void Dispose() <br />
    { <br />
        Dispose(true); <br />
    }<br />
<br />
protected:<br />
    virtual void Dispose(bool arg)<br />
    {<br />
        /* Clean up */ <br />
    }<br />
};<br />
<br />
public __gc class D : public B<br />
{<br />
protected:<br />
    virtual void Dispose(bool arg)<br />
    {<br />
        /* Clean up */<br />
        // call base classes implementation<br />
        B::Dispose(arg);<br />
    }<br />
};<br />
<br />
int _tmain(void)<br />
{<br />
    D * d = new D();<br />
    d->Dispose();<br />
    return 0;<br />
}<br />

int _tmain(void)
{
	D * d = new D();
	__try_cast<IDisposable*>(d)->Dispose();
	return 0;
}

<br />
public __gc class B : public IDisposable<br />
{<br />
public:<br />
    virtual ~B() <br />
    { <br />
        Console::WriteLine("B::~B()");<br />
        InternalDispose(false); <br />
    }<br />
<br />
    virtual  void Dispose() <br />
    { <br />
        Console::WriteLine("B::Dispose()");<br />
        InternalDispose(true); <br />
    }<br />
<br />
protected:<br />
    // renaming this function to InternalDispose solved my problem<br />
    virtual void InternalDispose(bool arg)<br />
    {<br />
        Console::WriteLine("B::InternalDispose(bool)");<br />
        /* Clean up */ <br />
    }<br />
};<br />
<br />
public __gc class D : public B<br />
{<br />
public:<br />
    // just to show that the function *is* virtual<br />
    void Dispose() <br />
    { <br />
        Console::WriteLine("D::Dispose()"); <br />
        B::Dispose();<br />
    }<br />
protected:<br />
<br />
    void InternalDispose(bool arg)<br />
    {<br />
        Console::WriteLine("D::InternalDispose(bool)");<br />
        /* Clean up */<br />
        // call base classes implementation<br />
        B::InternalDispose(arg);<br />
    }<br />
};<br />
<br />
int _tmain(void)<br />
{<br />
  B * b = new D();<br />
  b->Dispose(); // as virtual as can be *g*<br />
}<br />