FileVersionInfo ^ ver = FileVersionInfo::GetVersionInfo(Environment::GetCommandLineArgs()[0]);
String ^ myVer = ver->FileMajorPart + "." + ver->FileMinorPart + "." + ver->FileBuildPart + "." + ver->FilePrivatePart;

Version ^ ver = Environment::Version;
Console::WriteLine("Version Framework = {0}", ver);

OperatingSystem ^ os = Environment::OSVersion;
Console::WriteLine("Version OS = {0}", os);

Console::WriteLine("Nom utilisateur : {0}", Environment::UserName);

	// Nom de la machine
	String ^MachineName = Environment::MachineName;
	Console::WriteLine("Nom de la machine = {0}", MachineName);

Console::WriteLine("Mémoire allouée au process en cours : {0}", Environment::WorkingSet);

Console::WriteLine("La ligne de commande est : {0}", Environment::CommandLine);

// Arguments de ligne de commande
Console::WriteLine("Arguments de ligne de commande");
cli::array<String ^> ^args = Environment::GetCommandLineArgs();
for (int i = 0; i<args->Length; i++)
	Console::WriteLine("Args({0}) = {1}", i, args[i]);

int main(array<System::String ^> ^args)

IDictionary ^ env = Environment::GetEnvironmentVariables();
// Pour afficher une variable dont on connait le nom
Console::WriteLine("USERNAME = {0}", env["USERNAME"]);
// Pour lister toutes les variables
for each (String ^s in env->Keys)
	Console::WriteLine("{0} = {1}", s, env[s]);

// Pour générer toujours la même séquence, 
// on passe la même valeur au constructeur.
// Random rnd = new Random(100); 
 
// Initialisation par défaut basée sur le temps. 
// La séquence est différente à chaque fois.
Random ^rnd = gcnew Random();
 
// Génération de 15 nombres aléatoires compris entre 0 et 255
cli::array<unsigned char> ^ rndNumbers = gcnew cli::array<unsigned char>(15);
rnd->NextBytes(rndNumbers);
this->listBox1->Items->Clear();
for (int i=0; i<15; i++)
    // On peut aussi faire un modulo pour n'obtenir que 
    // des nombres entre 0 et 100 par exemples
    if (rndNumbers[i] > 100)
        listBox1->Items->Add(rndNumbers[i] % 100);
    else
        listBox1->Items->Add(rndNumbers[i]);
 
// Pour générer des nombres aléatoire de type Integer
int i = rnd->Next();
int j = rnd->Next(500, 1000); // j sera compris entre 500 et 999 inclu
 
// Pour générer des nombre aléatoire de type Double
// d sera compris entre 0,0 et 1,0. 
// Il suffit de combiner cet appel à celui de Next() 
// pour avoir des doubles supérieurs à 1,0
double d = rnd->NextDouble();

Console::WriteLine ("Saisissez un texte: ");
String ^ _Texte = Console::ReadLine ();
Console::WriteLine ("Vous avez écrit : " + _Texte);

System::GC::Collect();

#include <windows.h>
#pragma comment(lib, "Kernel32.lib")
....
GetModuleFileName(0, nom, MAX_PATH);

using namespace System::Diagnostics;

//Instanciation d'un objet StopWatch
Stopwatch ^monStopWatch = gcnew Stopwatch();
 
// Déclenchement du "chronomètre"
monStopWatch->Start();
 
// ///////////////////////////////
// Placez ici le code que vous voulez évaluer, cela peut être par exemple du code 'brut' ou
// alors l'appel d'un méthode...
// ///////////////////////////////
 
// Arrêt du "chronomètre"
monStopWatch->Stop();
 
// Le temps écoulé peut être récupéré très facilement avec un membre de StopWatch,
// de la façon suivante. Le résultat est exprimé en millisecondes
long tempsExecution;
tempsExecution = safe_cast<long>(monStopWatch->ElapsedMilliseconds);

using namespace System::Text::RegularExpressions;

String ^monTexte = "Une astuce de dvp.com ! Une astuce de Dvp.Com !";
 
// Paramétrage de notre expression régulière :
// Ici on spécifie que l'on ne veut pas tenir compte dela casse du
// texte dans nos remplacements.
Regex ^maRegEx = gcnew Regex("\\bdvp.com\\b", RegexOptions::IgnoreCase);
 
// Remplacement des occurences de "dvp.com" par "Developpez.com"
monTexte = maRegEx->Replace(monTexte, "Developpez.com");

pictureBox1->Image = Image::FromStream(Reflection::Assembly::GetExecutingAssembly()->GetManifestResourceStream("abc.bmp"));

	if (! EventLog::SourceExists("MonApplication"))
		EventLog::CreateEventSource("MonApplication", "MonJournal");
 
	EventLog^ MonJournal = gcnew EventLog();
	MonJournal->Source = "MonApplication";
 
	try 
	{
		// instructions à exécuter  (ex : division par zéro;
		int i = 0;
		Console::WriteLine(2/i);
	}
	catch(Exception^ ex) 
	{  
		// écrire l'erreur  
		MonJournal->WriteEntry(ex->Message,EventLogEntryType::Error); 
	}

	// Nombre d'écrans connectés
	int MonitorCount = SystemInformation::MonitorCount;
	Console::WriteLine("Nombre d'écrans connectés à l'ordinateur = {0}", MonitorCount);

#using "System.Windows.Forms.dll"
using namespace System::Windows::Forms;

	// Nombre de processeurs de la machine
	int countProc = Environment::ProcessorCount;
	Console::WriteLine("Nombre processeurs = {0}", countProc);

	// Vérification si un utilisateur appartient à un groupe de domaine donné
	WindowsPrincipal ^wp = gcnew WindowsPrincipal(WindowsIdentity::GetCurrent());
	if (wp->IsInRole("Developpez\\Moderateur") == true)
		Console::WriteLine("L'utilisateur fait bien partie du groupe Developpez\\Moderateur");
	else
		Console::WriteLine("L'utilisateur ne fait pas partie du groupe Developpez\\Moderateur");

	#using "System.Windows.Forms.dll"
	// ......
	switch (SystemInformation::BootMode)
	{
		case BootMode::Normal: 
			Console::WriteLine("Démarrage normal !"); 
			break;
		case BootMode::FailSafe:
			Console::WriteLine("Attention, on est en mode sans echec !");
			break;
		case BootMode::FailSafeWithNetwork:
			Console::WriteLine("Attention, on est en mode sans échec mais on a accès au réseau !"); 
			break;
      }

ref class MonExceptionApplication : ApplicationException
{
public:
    MonExceptionApplication() : ApplicationException("Exception personnalisée")
    { }
 
	MonExceptionApplication(String ^p_message) : ApplicationException("Exception personnalisée : " + p_message)
    { }
};
 
int main(array<System::String ^> ^args)
{
	try
	{
		throw gcnew MonExceptionApplication("rien à faire");
	}
	catch (MonExceptionApplication^ ex)
	{
		Console::WriteLine(ex->Message);
	}
    return 0;
}

using namespace Microsoft::Win32;

String ^AGetExtentionDescription(String ^ext)
{
	String ^description = GetExtentionDescription(ext);
	if (description == nullptr || description == "")
		return String::Format("Fichier {0}", ext);
	else
		return description;
}
 
String ^GetExtentionDescription(String ^ext)
{
	if (ext == nullptr || ext == "" || ext == ".")
		return nullptr;
	String ^description = "";
	try
	{
		RegistryKey ^keyDesc = Registry::ClassesRoot->OpenSubKey(ext, false);
		if (keyDesc == nullptr)
			return nullptr;
		else
		{
			try
			{
				if (keyDesc->GetValueKind("") != RegistryValueKind::String)
					return nullptr;
				else
				{
					description = (String^)keyDesc->GetValue("");
					if (description == nullptr || description == "")
						return nullptr;
					RegistryKey ^optionnalRedirection = Registry::ClassesRoot->OpenSubKey(description, false);
					if (optionnalRedirection == nullptr)
						return description;
					else
					{
						try
						{
							if (optionnalRedirection->GetValueKind("") != RegistryValueKind::String)
								return description;
							else
								return (String ^)optionnalRedirection->GetValue("");
						}
						finally
						{
							if (optionnalRedirection != nullptr)
								optionnalRedirection->Close();
						}
					}
				}
			}
			finally
			{
				if (keyDesc != nullptr)
					keyDesc->Close();
			}
		}
	}
	catch(Exception ^)
	{
		return nullptr;
	}
}
 
System::Void Form1_Load(System::Object^  sender, System::EventArgs^  e) 
{
	MessageBox::Show(AGetExtentionDescription(".exe"));
	MessageBox::Show(AGetExtentionDescription(".jpg"));
	MessageBox::Show(AGetExtentionDescription(".dat"));
	MessageBox::Show(AGetExtentionDescription(".iso"));
	MessageBox::Show(AGetExtentionDescription(".bmp"));
}