Destructor not called in static lib when function called from C++/CLI

When writing managed wrappers for native code that throws
exceptions, I catch any unmanaged exceptions and rethrow
them as managed exceptions.

The following simple C++/CLI example demonstrates the principle:

#include <exception>

struct TTester {
  TTester() { OutputDebugString("Constructor\n"); }
  ~TTester() { OutputDebugString("Destructor\n"); }
};

void NativeFunction(bool do_throw) {
  TTester t;
  if (do_throw)
    throw std::exception();
}

void ManagedWrapper(bool do_throw) {
  try{
    NativeFunction(do_throw);
  } catch (std::exception) {
    throw gcnew Exception();
  }
}

//test wrapper
int main(array<System::String ^> ^args) {
  ManagedWrapper(false);
  try {
    ManagedWrapper(true);
  } catch (Exception^) {
    OutputDebugString("Caught managed exception\n");
  }
  return 0;
}

The output of this program is as you would expect:

Constructor
Destructor
Constructor
Destructor
Caught managed exception

If, however, I move "NativeFunction" and "class TTester"
into a separately compiled library, the destructor of
TTester is not called when an exception is thrown.

EG:

//NativeFunction.h
#pragma once
void NativeFunction(bool do_throw);
//End NativeFunction.h

//NativeFunction.cpp - Compiled into TestLib.lib
#include <Windows.h>
#include "NativeFunc.h"
#include <exception>

struct TTester {
  TTester() {OutputDebugString("Constructor\n");}
  ~TTester() {OutputDebugString("Destructor\n");}
};

void NativeFunction(bool do_throw) {
  TTester t;
  if (do_throw)
    throw std::exception();
}
//END NativeFunction.cpp

//DestructorTest.exe Linked with TestLib.lib
// DestructorTest.cpp : main project file.
#include <Windows.h>
#include "NativeFunc.h"

using namespace System;

//catch native exceptions and throw them as managed
void ManagedWrapper(bool do_throw) {
  try{
    NativeFunction(do_throw);
  } catch (std::exception) {
    throw gcnew Exception();
  }
}

int main(array<System::String ^> ^args) {
  ManagedWrapper(false);
  try {
    ManagedWrapper(true);
  } catch (Exception^) {
    OutputDebugString("Caught managed exception\n");
  }
  return 0;
}

The output from this modified version is as follows:

Constructor
Destructor
Constructor
Caught managed exception

TTester::~TTester is not called!

I think this is an alarming issue. The author of
the library (in this case me) would be pretty
miffed to find that his destructors are not being
called because of the context in which the functions
are called.

This has made my library unusable from C++/CLI.
It seems that this would be common situation when
wrapping a native library that throws exceptions.
I have searched the MSDN Connect site but cannot
find any mention of it. Does anyone know if this
has come up before, and if there is a workaround?

--
regards

Martin Lafferty
Production Robots Engineering Ltd