Here is the scenario I'm trying to make work.

I've got 2 managed C++ classes, each of which wrappes an unmanaged C++
class, kind of like so:

__nogc class UnmanagedClassA
{
  public:
     void SetUnmanagedB( UnmangedClassB* val );
...
};
__gc class ManagedClassA
{
  public:
    MangedClassA() :
      m_unmanagedA(__nogc new UnmanagedClassA() )
    { }

  private:
    __nogc UnmanagedClassA* m_unmanagedA;
};

__nogc class UnManagedClassB
{
...
};
__gc class ManagedClassB
{
  public:
    MangedClassB() :
      m_unmanagedB(__nogc new UnmanagedClassB() )
    { }

  private:
    __nogc UnmanagedClassB* m_unmanagedB;
};

The managed wrapper classes were created to allow using the unmanaged
classes in C#.

I need to be able to hand an instance of ManagedClassB to ManagedClassA
and have it pass the m_unmanagedB pointer to a method of m_unmanagedA.
Something like this:

void ManagedClassA::SetManagedB( ManagedClassB* b )
{
  m_unmanagedA->SetUnmanagedB( b->m_unmanagedB );
}

My first question is: what is the best way to accomplish this task
(idealy without making m_unmangedB public)? and my second question is
why doesn't my solution below work?

Below is my solution that doesn't quite work:

In traditional C++ I would simply declare ManagedClassA as a private
friend of ManagedClassB and everything would be good, but I have come
to the understanding that friends aren't allowed in managed C++ so I've
created a unmanged nested class to solve the problem, something like
this

__gc class ManagedClassB
{
  public:
    ManagedClassB() :
      m_unmanagedB(__nogc new UnmanagedClassB() )
    { }

  private:
    __nogc UnmanagedClassB* m_unmanagedB;

  public:
  __nogc class NestedFriendClass
  {
    public:
       NestedFriendClass( ManagedClassB* owner)
       {
          m_owner = gcroot<ManagedClassB*>(owner);
       }
       UnmanagedClassB* GetUnmanagedB()
       {
          return m_owner->m_unmanagedB;
       }
    private:
       gcroot<ManagedClassB*> m_owner;
  }
};

And the MangedClassA::SetManagedB() method becomes something like.

void ManagedClassA::SetManagedB( ManagedClassB* b )
{
  ManagedClassB::NestedFriendClass temp( b );
  m_unmanagedA->SetUnmanagedB( temp.GetUnmanagedB() );
}

Now this all compiles fine but when I run it I get a
'System.FieldAccessException' exception in
ManagedClassB::NestedFriendClass::GetUnmanagedB().

Now this implies to me that the public, protected, and private access
specifiers are being enforced at run time for unmanaged code which is
surprising to me, can anyone tell me what's going on here.

I will admit that I'm relatively new to the managed C++ and C# worlds
so I may be missing something simple here. I do consider myself a very
advanced traditional C++ programmer.
Also I'm currently using MS Visual Studio 2003.NET and we are upgrading
to 2005.NET next week.