using namespace System::Threading;				
public ref class Threads : public System::Windows::Forms::Form
{
    // ........
    private : Thread ^_threadCalculs1;
}

private :void ThrFunc1()
{ 
    // Traitement effectué par le thread. Calculs est une fonction quelconque de notre Form
    try
    {
        Calculs(1000) ;
    }
    catch (Exception ^ex)
	{
	   System::Diagnostics::Debug::WriteLine(ex->ToString());
    }
}

private : void StartThread()
{
    // ThrFunc1 est la fonction exécutée par le thread.
	_threadCalculs1 = gcnew Thread(gcnew ThreadStart(this, &Threads::ThrFunc1));
    // Il est parfois pratique de nommer les threads surtout si on en créé plusieurs.
    _threadCalculs1->Name = "Thread1"; 
    // Démarrage du thread.
    _threadCalculs1->Start();
}

using namespace System;
using namespace System::Threading;	
 
ref class ThreadParametre
{
private:
	String ^_text;
    int _entier;
public:
    // Constructeur
    ThreadParametre(String ^texte, int entier)
    {
        _text = texte;
        _entier = entier;
    }
    // Exécution de la méthode du thread
    void ExecuteThread()
    {
        for(int i = 0; i < _entier; i++)
        {
			Console::WriteLine("Index : " + i);
			Console::WriteLine("Message : " + _text);
        }
    }
};
 
int main(array<System::String ^> ^args)
{
	ThreadParametre ^ExempleThread = gcnew ThreadParametre("Message de test", 5);
	Thread ^t = gcnew Thread(gcnew ThreadStart(ExempleThread, &ThreadParametre::ExecuteThread));
	t->Start();
 
	return 0;
}

using namespace System;
using namespace System::Threading;	
 
public ref class Threads : public System::Windows::Forms::Form
{
	private : Thread ^ _threadCalculs1;
	// Evènement de signal de fin de thread
	private : AutoResetEvent ^_endThreadCalculsEvent;
public:
	Threads(void)
	{
		InitializeComponent();
		_endThreadCalculsEvent = gcnew AutoResetEvent(false);
	}
 
	private :void ThrFunc1()
	{ 
		// Traitement effectué par le thread. Calculs est une fonction quelconque de notre Form
		try
		{
			Calculs(1000) ;
		}
		catch (Exception ^ex)
		{
			System::Diagnostics::Debug::WriteLine(ex->ToString());
		}
	}
 
	private : void StartThread()
	{
		// ThrFunc est la fonction exécutée par le thread.
		_threadCalculs1 = gcnew Thread(gcnew ThreadStart(this, &Threads::ThrFunc1));
		// Il est parfois pratique de nommer les threads surtout si on en créé plusieurs.
		_threadCalculs1->Name = "Thread1"; 
		// Démarrage du thread.
		_threadCalculs1->Start();
	}
	void Calculs(int tempo)
	{
		// Si l'événement est à l'état signalé, WaitOne renvoie true et la boucle se termine.
		while (! _endThreadCalculsEvent->WaitOne(tempo, false) )
		{
			// C'est ici ou notre thread fait son travail
			// .....
		}
	}
 
	// pour arreter le thread
	private: System::Void button1_Click_1(System::Object^  sender, System::EventArgs^  e) 
	{
		// L'événement passe à l'état signalé
		_endThreadCalculsEvent->Set();
		// On attend la fin du thread.
		_threadCalculs1->Join(); 
	}
};

// Forcer la fin du thread
void AbortThread()
{
    _threadCalculs1->Abort();  // On demande au runtime d'arrêter le Thread
    _threadCalculs1->Join();   //  On attend la fin du thread.
}

using namespace System::Threading;

Thread::CurrentThread->Name = "MainThread";

ref class SingleInstanceApp
{
private:
	System::Threading::Mutex ^_siMutex;
	bool _siMutexOwned;
public:
	SingleInstanceApp(String ^name)
	{
		_siMutex = gcnew System::Threading::Mutex(false, name);
		_siMutexOwned = false;
	}
 
	~SingleInstanceApp()
	{
		// Libération du mutex si il a été acquis
		if (_siMutexOwned) 
			_siMutex->ReleaseMutex();
	}
 
	// Application déjà lancée ?
	bool IsRunning()
	{
		// Acquisition du mutex.
		// Si _siMutexOwned vaut true, l'application acquiert le mutex car il est "libre"
		// Sinon le mutex a déjà été acquis lors du lancement d'une instance précédente
		_siMutexOwned =  _siMutex->WaitOne(0, true);
		return !(_siMutexOwned);
	}
};

SingleInstanceApp ^app = gcnew SingleInstanceApp("{123456789 - ABCD - EFEG - XXXX}");
if (app->IsRunning())
	MessageBox::Show("Application déjà lancée");
else
	Application::Run(gcnew Form1());
delete app;

void StartProcess()
{
	// Instance de la classe Process
	System::Diagnostics::Process ^proc = gcnew System::Diagnostics::Process();
	// Nom de l'exécutable à lancer
	proc->StartInfo->FileName = "iexplore.exe";
	// Arguments à passer à l'exécutable à lancer
	proc->StartInfo->Arguments="http://www.developpez.com";
	// Démarrage du processus
	proc->Start() ;
	// On libère les ressources dont on n'a plus besoin.
	proc->Close(); // Attention Close ne met pas fin au processus.
}

//Instance de la classe System.Diagnostics.Process
System::Diagnostics::Process ^ proc = gcnew System::Diagnostics::Process();
//Nom du fichier dont l'extension est connue du shell à ouvrir
proc->StartInfo->FileName = "monfichier.txt";
//Démarrage du processus. Notepad (si il est associé aux fichiers .txt) sera alors lancé et ouvrira le fichier monfichier.txt
proc->Start();
//On libère les ressources
proc->Close();

String ^ RedirectStdOutput(String ^nomProcess)
{
	System::Diagnostics::Process ^ proc = gcnew System::Diagnostics::Process();
	// On désactive le shell
	proc->StartInfo->UseShellExecute = false;
	// On redirige la sortie standard
	proc->StartInfo->RedirectStandardOutput = true;
	// On définit la commande 
	proc->StartInfo->FileName = nomProcess;
	// Démarrage de la commande
	proc->Start();
	// Attente de la fin de la commande
	proc->WaitForExit();
	// Lecture de la sortie de la commande
	String ^ output = proc->StandardOutput->ReadToEnd();
	// Libération des ressources
	proc->Close();
	return output;
}

// Pour tous les processus en cours sur l'ordinateur local
array<System::Diagnostics::Process ^> ^ prc  = Process::GetProcesses();
// Pour tous les processus notepad en cours sur l'ordinateur local
array<System::Diagnostics::Process ^> ^ prc = Process::GetProcessesByName("notepad");

// Pour les applications consoles
proc->Kill();
// Libération des ressources
proc->Close();

// Pour les applications avec une interface graphique (et donc une pompe de messages)
// Si l'appel échoue, on peut alors forcer la fermeture avec Kill.
proc->CloseMainWindow();
// Libération des ressources
proc->Close();