using System;
	using System.Reflection;

	Version ver = Assembly.GetEntryAssembly().GetName().Version);
	string myVer = ver.ToString();

        

          
	// Conversion d'un entier vers une chaines de caractères
	int i = 10;
	string s = Convert.ToString(i);
	// ou plus simplement :
	// string s = i.ToString();

	// Conversion d'une chaine vers un entier
	i = Convert.ToInt32(s);
	// Notez que si la conversion ne peut se faire, une exception est levée.
	// Ce serait le cas si s = "NonNumérique"
  
  // Conversion d'un entier en une chaine hexadécimale :
  s = Convert.ToString(i, 16);
  
  // Conversion d'un tableau d'octets en base64 :
  byte[] bytes = new byte[] { 0x23, 0xff, 0x40, 0xcc };
  s = Convert.ToBase64String(bytes);

        

          
	string s = "35000";
	int i = int.Parse(s);
	
        

          
	string s = "35000";
	int i;
	if (int.TryParse(s, out i))
	{
		// Conversion réussie
	}
	else
	{
		// Conversion échouée
	}
	
        

          
    public class SaisiTexte
    {
        private string _Texte;

        public static void Main()
        {
            Console.WriteLine("Saisissez un texte: ");
            _Texte = Console.ReadLine();
            Console.WriteLine("Vous avez écrit : " + _Texte);
        }
    }

        

          
      Console.Title = "Mon titre";
      
        

System.GC.Collect()

          
	using System.Runtime.InteropServices;
	//...
	
	[DllImport("user32.dll")]
	static extern int FlashWindow (int hwnd, int bInvert);

        

          
// Chemin de l'exécutable
// Le premier élément du tableau retourné est le chemin de l'exécutable
string exePath = Environment.GetCommandLineArgs()[0];
// Répertoire de l'exécutable
string exeDir = System.IO.Path.GetDirectoryName(exepath);

        

          
string exePath = System.Reflection.Assembly.GetEntryAssembly().Location;
string exeDir = System.IO.Path.GetDirectoryName(exePath);

        

          
string exeDir = Application.StartupPath;

        

          
string pathModule = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetEntryAssembly().Location);

        

          
System.IO.Directory.GetCurrentDirectory();

        

          
	// Répertoire courant
	Console.WriteLine("Le répertoire courant est : {0}", Environment.CurrentDirectory);

        

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

        

          
	// Arguments de ligne de commande
	Console.WriteLine("Arguments de ligne de commande");
	string[] args = Environment.GetCommandLineArgs();
	int j = args.Length;
	for (i = 0; i<j; i++)
		Console.WriteLine("Args({0}) = {1}", i, args[i]);

        

          
// Obtenir une variable d'environement en particulier
string userName = Environment.GetEnvironmentVariable("USERNAME");

// Enumérer toutes les variables d'environmeent
foreach (DictionaryEntry de in Environment.GetEnvironmentVariables())
{
    Console.WriteLine("{0} = {1}", de.Key, de.Value);
}

        

          
		using System.Threading;
					
        class SingleInstanceApp : IDisposable
        {
            // Mutex
            Mutex _siMutex;
            bool _siMutexOwned;

            // Constructeur
            public SingleInstanceApp(string name)
            {
                _siMutex = new Mutex(false, name);
                _siMutexOwned = false;
            }

            // Application déjà lancée ?
            public 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);
            }

            // Membre de IDisposable
            public void Dispose()
            {
                // Libération du mutex si il a été acquis
                if (_siMutexOwned)
                    _siMutex.ReleaseMutex();
            }
        }


        

          
        static void Main()
        {
            // En utilisant using, app.Dispose() est appelée automatiquement
            // Merci CSharp ;-)
            using (SingleInstanceApp app = new SingleInstanceApp("{123456789 - ABCD - EFEG - XXXX}"))
            {
                if (app.IsRunning())
                    MessageBox.Show("Application déjà lancée");
                else
                    Application.Run(new Form1());

            }
        }

        

          
	[STAThread] 
	static void Main()
	{ 
		if (TestSiApplicationDejaLancee() == false) 
		{ 
			// Première instance de l'application 
			Application.EnableVisualStyles(); 
			Application.SetCompatibleTextRenderingDefault(false); 
			Application.Run(new Form1()); 
		} 
		else 
		{ 
			// L'application a déjà été lancée 
			Application.Exit(); 
		} 
	} 
	
	static bool TestSiApplicationDejaLancee() 
	{ 
		// Récupération du processus courant 
		Process currentProcess = Process.GetCurrentProcess(); 
		
		// Parcours de la liste des processus de la machine 
		foreach (Process p in Process.GetProcesses()) 
		{ 
			// Test si le processus courant est bien différent du processus de la liste 
			// et que les deux processus en question ont le même nom 
			if (p.Id != currentProcess.Id && p.ProcessName.Equals(currentProcess.ProcessName) == true) 
				return true; 
		} 
		
		return false; 
	} 
		
		
        

          
        private void Button1_Click(object sender, System.EventArgs e)
        {
            // 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 = new Random();

            // Génération de 15 nombres aléatoires compris entre 0 et 255
            byte[] rndNumbers = new Byte[15];
            rnd.NextBytes(rndNumbers);
            ListBox1.Items.Clear();
            for (byte 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

            // 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();
        }

        

          
            string fileName = "fichier.txt";
            Assembly assembly = Assembly.GetExecutingAssembly();
            string resourceFileName = assembly.GetName().Name + "." + fileName;
            Stream stream = assembly.GetManifestResourceStream(resourceFileName);

        

          
      Stopwatch maMesureDeTemps = new Stopwatch();

      // Démarrage de l'intervalle de temps
      maMesureDeTemps.Start();

      // ...

      // Fin de l'intervalle de temps
      maMesureDeTemps.Stop();

      Console.WriteLine("L'exécution du code a pris : {0}", maMesureDeTemps.Elapsed.ToString());