Visual Studio C++ DLL using managed code

Hi, I'm a programmer, but not a C++ programmer. I'm really looking for someone who can look at my example code and immediately knows what to do. I don't need someone who has to go away and look it up on Google - because I can do that myself. I'm using Microsoft Visual Studio 2015 with /clr. C++. I'm writing a DLL. I've written lots of unmanaged code like this, but now I'd like to incorporate some managed code, but I'm having problems combining the two. I've attached some simplified code, with an example of opening, writing and closing a file using managed code. I call my DLL from a 3rd party app (I have no control over this 3rd party app). This app creates a single memory space for the DLL. In order to call the DLL multiple times with separate settings I create a class and use a pointer to that class for subsequent calls. The pointer is then stored in the ->Tag of the object from the 3rd party app (as an int). The order of calling the DLL is xCreateClass myTest_open myTest_write myTest_close xDestroyClass The code below doesn't work because I'm redeclaring StreamWriter^ sw with each DLL call. With unmanaged code I would put this file declaration in the public: scope of the myData class. But with managed code it won't allow this. Looking on the internet it says I should declare my class with a ref statement ref class myData But when I do this it throws lots of errors around the use of my data pointers in the DLL calls. So I think what I need is that my data pointers should be rewritten in managed code, but I don't know how to do this. I say I think because I'm a bit lost right now and maybe there is a different way to do this. So hopefully you look at this code and think 'that's easy'! If we go ahead I can send you the VS project. Thanks //Used to connect with 3rd party app #import "[login to view URL]" no_namespace #using <[login to view URL]> using namespace System; using namespace System::IO; #pragma unmanaged BOOL APIENTRY DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) { switch (ul_reason_for_call) { case DLL_PROCESS_ATTACH: case DLL_THREAD_ATTACH: case DLL_THREAD_DETACH: case DLL_PROCESS_DETACH: break; } return TRUE; } #pragma managed class myData { public: //variable definitions //StreamWriter^ sw; //this declaration needs to be here, but it isn't allowed here myData() { //variable declarations } void xx_open() { StreamWriter^ sw; String^ path; path = Environment::CurrentDirectory + "\\[login to view URL]"; if (System::IO::File::Exists(path)) System::IO::File::Delete(path); sw = gcnew StreamWriter(path); } void xx_write() { StreamWriter^ sw; //redeclaring - doesn't work because this call is referencing a different sw from previous xx_open call sw->WriteLine("Hello - Goodbye"); sw->Flush(); } void xx_close() { StreamWriter^ sw; //redeclaring - doesn't work because this call is referencing a different sw from previous xx_open and xx_write calls if (sw != nullptr) { sw->Close(); } } }; //DLL calls int __stdcall xCreateClass(::IEasyLanguageObject * elObjPtr) { myData * myDataPtr = (myData *)elObjPtr->Tag; if (myDataPtr == 0) { myDataPtr = new myData(); elObjPtr->Tag = (__int64)myDataPtr; } return 1; } int __stdcall xDestroyClass(::IEasyLanguageObject * elObjPtr) { myData * myDataPtr = (myData *)elObjPtr->Tag; if (myDataPtr != 0) { delete myDataPtr; elObjPtr->Tag = 0; } return 1; } void __stdcall myTest_open(::IEasyLanguageObject * elObjPtr) { myData * myDataPtr = (myData *)elObjPtr->Tag; if (myDataPtr != 0) { myDataPtr->xx_open(); } } void __stdcall myTest_write(::IEasyLanguageObject * elObjPtr) { myData * myDataPtr = (myData *)elObjPtr->Tag; if (myDataPtr != 0) { myDataPtr->xx_write(); } } void __stdcall myTest_close(::IEasyLanguageObject * elObjPtr) { myData * myDataPtr = (myData *)elObjPtr->Tag; if (myDataPtr != 0) { myDataPtr->xx_close(); } }