Managed C++/CLI

Shrink ▲   
struct ThreadData {
    // some thread specific data
};
...
DWORD g_dwThreadIndex;

extern "C" BOOL WINAPI DllMain(HINSTANCE hInstance, 
                      DWORD dwReason, LPVOID /*pReserved*/)
{
    ThreadData* pData;

    switch (dwReason) {
        case DLL_PROCESS_ATTACH:

            // allocate a TLS index

            g_dwThreadIndex = ::TlsAlloc();
            if (g_dwThreadIndex == TLS_OUT_OF_INDEXES)
                return FALSE;

            //break;        // execute the DLL_THREAD_ATTACH code

        case DLL_THREAD_ATTACH:

            // allocate memory for this thread

            pData = (ThreadData*) ::LocalAlloc(LPTR, sizeof(ThreadData));
            if (pData == 0)
                return FALSE;

            ::TlsSetValue(g_dwThreadIndex, (LPVOID) pData);
            break;

        case DLL_THREAD_DETACH:

            // release memory for this thread

            pData = (ThreadData*) ::TlsGetValue(g_dwThreadIndex);
            if (pData != 0)
                ::LocalFree((HLOCAL) pData);
            break;

        case DLL_PROCESS_DETACH:

            // release memory for this thread

            pData = (ThreadData*) ::TlsGetValue(g_dwThreadIndex);
            if (pData != 0)
                ::LocalFree((HLOCAL) pData);

            // release the TLS index

            ::TlsFree(g_dwThreadIndex);
            break;
    }

    return TRUE;
}

    ...
};

DllMain entry point (Process.h) - Win32 apps | Microsoft Learn[^]

The DLL is being loaded into the virtual address space of the current process as a result of the process starting up or as a result of a call to LoadLibrary. DLLs can use this opportunity to initialize any instance data or to use the TlsAlloc function to allocate a thread local storage (TLS) index.

ForNow wrote:

the next thread that comes by can change its value

ForNow wrote:

and then before the current thread access the storage set by tlssetvalue
another thread does a tlsallloc g_dwThreadindex becomes 6

ForNow wrote:

there are two types of dll’s

int foo(int i)
   {
   if (i <= 1) return 1;
   return i + foo(i - 1);
   }

int foo(int i)
   {
   if (i <= 1) return 1;
   return i + bar(i);
   }
int bar(int i)
   {
   return foo(i - 1);
   }

Quote:

This overload of the Fill method does not implicitly call Close on the ADO object when the fill operation is complete. Therefore, always call Close when you are finished using ADO Recordset or Record objects. This makes sure that the underlying connection to a data source is released in a timely manner, and also prevents possible access violations because of unmanaged ADO objects being reclaimed by garbage collection when existing references still exist.

System::Action <int> ^body = gcnew System::Action <int>(MainForm::Body);
ParallelLoopResult ^result = Parallel::For(0, 10, body);

namespace CppTutorial {

	using namespace System;
    using namespace System::Threading::Tasks;
	using namespace System::Windows::Forms;

	/// <summary>
	/// Summary for MainForm
	/// </summary>
	public ref class MainForm : public System::Windows::Forms::Form
	{
	public:
		MainForm(void)
		{
			InitializeComponent();
			//
			//TODO: Add the constructor code here
			//
		}

	protected:
		/// <summary>
		/// Clean up any resources being used.
		/// </summary>
		~MainForm()
		{
			if (components)
			{
				delete components;
			}
		}

	private: System::Windows::Forms::TextBox ^textBox1;

	protected:

	private:
		/// <summary>
		/// Required designer variable.
		/// </summary>
		System::ComponentModel::Container ^components;

#pragma region Windows Form Designer generated code
		/// <summary>
		/// Required method for Designer support - do not modify
		/// the contents of this method with the code editor.
		/// </summary>
		void InitializeComponent(void)
		{
			this->textBox1=(gcnew System::Windows::Forms::TextBox());
			this->SuspendLayout();
			// 
			// textBox1
			// 
			this->textBox1->Dock=System::Windows::Forms::DockStyle::Fill;
			this->textBox1->Location=System::Drawing::Point(0,0);
			this->textBox1->Multiline=true;
			this->textBox1->Name=L"textBox1";
			this->textBox1->Size=System::Drawing::Size(563,451);
			this->textBox1->TabIndex=0;
			// 
			// MainForm
			// 
			this->AutoScaleDimensions=System::Drawing::SizeF(6,13);
			this->AutoScaleMode=System::Windows::Forms::AutoScaleMode::Font;
			this->ClientSize=System::Drawing::Size(563,451);
			this->Controls->Add(this->textBox1);
			this->Name=L"MainForm";
			this->Text=L"MainForm";
			this->Shown+=gcnew System::EventHandler(this,&MainForm::MainForm_Shown);
			this->ResumeLayout(false);
			this->PerformLayout();

		}
#pragma endregion

  public:

  static MainForm ^staticmain;
  Random ^rand1;
	
  static void Body(int index)
  {
	// Randomly slow down thread
	int r=staticmain->rand1->Next(1000000);
	for(int i=0;i<r;i++){}
	// Append index and rnd text
	staticmain->textBox1->AppendText("i: "+Convert::ToString(index)+"  -   r: "+Convert::ToString(r)+"\r\n");
	// Call another MainForm member from inside Body
	staticmain->AnotherMethod();
  }

  System::Void MainForm_Shown(System::Object^ sender,System::EventArgs^ e) 
  {
	// Save main as static for use in Body()
	staticmain=this;
	// Allocate Random object for use in Body()
    rand1=gcnew Random();
	// Stop cross thrad exeptions
	textBox1->CheckForIllegalCrossThreadCalls=false;
    System::Action <int> ^body = gcnew System::Action <int> (MainForm::Body);
    ParallelLoopResult ^result = Parallel::For(0, 20, body);
  }

	void AnotherMethod()
	{
		int test=1;
	}

  };
}