CV
Langages
- C
- PHP
- Java
- Perl
- Ruby
- Javascript
- Flex 3
- Python
- GO
- C#
- TCL
- Bash
Liens
Articles
Contact

Langage C#

Expertise (2/5)

J'ai utilisé le C# pendant quelques mois, pour intervenir sur un logiciel qui tourne sous UNIX et qui a été développé en utilisant MONO.

Les classes
Les espaces de noms
Les membres statiques
Delegates
Surcharge d'opérateur
Compilation conditionnelle
Les directives
Les fichiers
Les exceptions
Les expressions régulières
Les sockets
Les threads

Les classes

using System;
using System.IO;
using System.Text;

// ----------------------------------------------------
// Test 1
// ----------------------------------------------------

public class A
{
	public A() { Console.WriteLine("\tNew A"); }
}

public class B : A
{
	public B() { Console.WriteLine("\tNew B"); }
}

// ----------------------------------------------------
// Test 2
// La modificateur d'accés par défaut pour les classes
// est "internal".
// Les classes qui présentent le modificateur d'accès
// "internal" ne sont accessibles que depuis l'assembly
// dans lequel elles sont déclarées.
// ----------------------------------------------------

internal class C // Identique à "class C" (sans le modificateur d'accès "internal")
{
	public C() { Console.WriteLine("\tNew C"); }
}

internal class D : C
{
	public D() { Console.WriteLine("\tNew D"); }
}

// ----------------------------------------------------
// Test 3
// Une classe qui présente le modificateur d'accès 
// "private" ne peut être déclarée qu'à l'intérieur
// d'une classe.
// ----------------------------------------------------

public class E
{
	internal class F
	{
		public F() { Console.WriteLine("\tNew F"); }
	}

	public E()
	{
		F objectF = new F();
		Console.WriteLine("\tNew E");
	}
}

// ----------------------------------------------------
// Test 4
// Une classe qui présente le modificateur "abstract"
// ne peut être instanciée. En général, elle sert de
// classe de base.
// ----------------------------------------------------

abstract public class G
{
	// Définition de la méthode "methose1()" et implementation par défaut
	public void methode1() { Console.WriteLine("\tMethode1"); }
	// Définition de la méthode "methose2()" et implementation par défaut
	public void methode2() { Console.WriteLine("\tMethode2"); }
	// Définition d'une méthode qui doit OBLIGATOIREMENT être implémentée dans les classes dérivées
	public abstract void methode3();
}

public class H : G // Hérite des implémentations par défaut des méthodes "methode1" et "methode2"
{
	public H() { Console.WriteLine("\tNew H"); }
	// Il est OBLIGATOIRE de fournir une implémentation pour la méthode "méthode3"
	public override void methode3() { Console.WriteLine("\tMethode3"); }
}

public class I : G // Redéfinit l'implémentation par défaut de la méthode "methode1"
{
	public I() { Console.WriteLine("\tNew I"); }
	// Il est OBLIGATOIRE de fournir une implémentation pour la méthode "méthode3"
	public override void methode3() { Console.WriteLine("\tMethode3"); }
	// Redéfinit l'implémentation de la méthode "methode1"
	public new void methode1() { Console.WriteLine("\tNouvelle methode1"); }
}

// ----------------------------------------------------
// Test 5
// ----------------------------------------------------

interface J
{
	void mth1(); // Cette méthode doit OBLIGATOIREMENT recevoir une implémentation dans les classes dérivées.
	             // Il n'est pas possible de fournir une implémentation par défaut ici.
	void mth2(); // Idem que pour "mth1()"
}

public class K : J
{
	// Si mth1() et mth2() ne reçoivent pas d'implémentation, la compilation n'est pas possible
	public void mth1() { Console.WriteLine("\tImplémentation de mth1"); }
	public void mth2() { Console.WriteLine("\tImplémentation de mth2"); }
}

// ----------------------------------------------------
// Test 6
// Une classe qui présente le modificateur "sealed" ne
// peut pas avoir de classes dérivées.
// Une méthode peut être déclarée "sealed" si elle
// "override" une methode de base.
// ----------------------------------------------------

sealed public class L
{
	public L() { Console.WriteLine("\tNew L"); }
}

// La ligne commentée ci-dessous produirait une errer de compilation
// public class M : L {} 

// ----------------------------------------------------
// Test 7
// ----------------------------------------------------

public class L
{
	public L() { Console.WriteLine("\tNew L"); }
	public voit mth() { Console.WriteLine("\tMéthode L.mth"); }
}



class Program
{
	static void Main(string[] args)
	{
		// Test 1
		Console.WriteLine("Test 1");
		A objectA = new A(); // Print "New A"
		B objectB = new B(); // Print "New A" and "New B"
		
		// Test 2
		Console.WriteLine("Test 2");
		C objectC = new C();
		D objectD = new D();
		
		// Test 3
		Console.WriteLine("Test 3");
		E objectE = new E();
		
		// Test 4
		Console.WriteLine("Test 4");
		H objectH = new H();
		objectH.methode1();
		objectH.methode2();
		objectH.methode3();
		I objectI = new I();
		objectI.methode1();
		objectI.methode2();
		objectI.methode3();
		
		// Test 5
		Console.WriteLine("Test 5");
		K objectK = new K();
		objectK.mth1();
		objectK.mth2();
		
		// Test 6
		Console.WriteLine("Test 6");
		L objectL = new L();
		
	}
}

Les espaces de noms

Les membres statiques

using System;
using System.IO;
using System.Text;

// ---------------------------------------------------------------------------------------- //
// STATIC Mmmbers (attributes and methods)                                                  //
// ---------------------------------------------------------------------------------------- //

class MultiCompter
{
	// "static" attributs belong to the class (not the object)
	static private int n = 0;
	
	public void add()   { n += 1; }
	public void print() { Console.WriteLine("n = {0}", n); }
	
	// "static" methods belong to the class (not the object)
	// Warning with multi-thread programming!
	static public void goahead() { int sn = 0; }
}

// ---------------------------------------------------------------------------------------- //
// STATIC classes                                                                           //
// ---------------------------------------------------------------------------------------- //

static class StaticClass
{
	// A "static class" can not contain instance members (following code will generate a compilation error)
	// private int n = 0;
	// public void add() { n += 1; }

	static private int n = 0;
	static public void add() { n += 1; }
	static public void print() { Console.WriteLine("n = {0}", n); }
}


class Program
{
	static void Main(string[] args)
	{
		// TEST 1: Static members
	
		MultiCompter o1 = new MultiCompter();
		MultiCompter o2 = new MultiCompter();
		
		o1.add();
		o1.add();
		o1.add();
		o2.print();  // Will print the value "3"
		
		// TEST 2: Static classes
		// "static" classes can not be instancied (following code will generate a compilation error)
		// StaticClass o3 = new StaticClass();
		
		StaticClass.add();
		StaticClass.print();
	}
}

Delegates

using System;
using System.IO;

class classe
{
	public int add (int a, int b) { return a+b; }
	public int sub (int a, int b) { return a-b; }
	public int mul (int a, int b) { return a*b; }
	
	// "OP" représente le nom d'une classe.
	private delegate int OP (int a, int b);
	// Tableau d'objets de la classe "OP".
	// Ce tableau contiendra une liste de "pointeurs sur fonctions".
	private OP[] handlers;
	// Utilisé pour illustrer la chaînage des délégates
	private OP listop;
	
	
	// Doit être déclaré "public" pour être assigné à un attribut "public".
	public delegate int OPE (int a, int b);
	// Objet de la classe "OPE".
	public OPE addition;
	

	
	public classe()
	{
		// Assignation d'un delegate en particulier
		addition = add;
		
		// Création d'un tableau de delagates
		handlers = new OP[3];
		handlers[0] = add;
		handlers[1] = sub;
		handlers[2] = mul;
		
		// Création d'une chaîne de delegates
		// L'exécution de "listop" entraine l'exécution, dans l'ordre de "add", "sub","mul","add".
		OP d1 = add;
		OP d2 = sub;
		OP d3 = mul;
		listop = d1 + d2 + d3 + new OP(add);
	}
	
	public void callall (int a, int b)
	{
		Console.WriteLine ("Tableau de delegates:\n");
		foreach (OP func in handlers)
		{ Console.WriteLine ("Tableau = {0}\n", func(a,b)); }
		
		Console.WriteLine ("Chaîne de delegates:\n");
		Console.WriteLine ("Chaîne: {0}\n", listop(a,b));
	}
	
}

class Program
{
	static void Main(string[] args)
	{
		classe c = new classe();
		c.callall(10, 30);
		Console.WriteLine ("Appel de la méthode publique: {0}\n", c.addition(2, 5));
	}
}

Surcharge d'opérateur

using System;
using System.IO;

class Complex
{
	private int entiere;
	private int imaginaire;
	
	public Complex(int e, int i)
	{
		entiere    = e;
		imaginaire = i;
	}
	
	// Syntaxe à utiliser pour surcharger un opérateur
	public static Complex operator + (Complex c1, Complex c2)
	{ return new Complex(c1.entiere, c2.imaginaire); }
	
	// La méthode ToString est définie par défaut.
	// Cette méthode est appelée lors des casts implicites en chaînes de caractères.
	// On la surcharge pour l'adapter à l'objet.
	public override string ToString()
	{
		string sentiere    = Convert.ToString(entiere);
		string simaginaire = Convert.ToString(imaginaire);
		string res = string.Concat(sentiere, ":", simaginaire);
		return res;
	}
}

class Program
{
	static void Main(string[] args)
	{
		Complex c1 = new Complex(1, 2);
		Complex c2 = new Complex(3, 4);
		Complex c3 = c1 + c2;
		Console.WriteLine ("({0}) + ({1}) = ({2})\n", c1, c2, c3);
	}
}

Compilation conditionnelle

Les directives

using System;
using System.IO;

class Process
{
	private void logger (string message)
	{
		// Contrairement au C, la directive de compilation ""#if du c# ne peut être utilisée que pour une
		// seule chose : tester l'existence d'un flag (ou d'une combinaison de flags).
		// Pour activer le code associé au mode DEBUG, deux solutions sont possibles:
		//  [1] à la compilation: gmcs -define:DEBUG prog.cs
		//  [3] dans le code, en utilisant la directive "#define".
		#if DEBUG
		Console.WriteLine ("DEBUG: {0}\n", message);
		#elif INFO 
		Console.WriteLine ("INFO: {0}\n", message);
		#elif WARNING
		Console.WriteLine ("WARNING: {0}\n", message);
		#else
		Console.WriteLine ("{0}\n", message);
		#endif
	}
	
	public Process()
	{
		logger ("Appel du constructeur.");
	}
}

class Program
{
	static void Main(string[] args)
	{
		Process c = new Process();
	}
}

Les fichiers

using System;
using System.IO;
using System.Text;



class Program
{
    // ----------------------------------------------------------------------------------- //
    // The method Main() is executed first. This is the entry point.                       //
    // ----------------------------------------------------------------------------------- //
    
    static void Main(string[] args)
    {
        TextReader inputfd;
        int MAXFIELDS=255;
        int cidsize=0;
        int[] cids = new int[MAXFIELDS];

        // ------------------------------------------------------------------------------ //
        // Parse the commande line.                                                       //
        // Unlike C or C++, args[0] represents the first argument (not the program's name //
        // itself).                                                                       //
        // ------------------------------------------------------------------------------ //
    
        if (args.Length < 2)
        {
            Console.WriteLine("Usage: csvfilter <CSV file> <Field number> [<Field number> ...]");
            return;
        }
        
        if (args.Length - 1 > MAXFIELDS)
        {
            Console.WriteLine("ERROR: Too many arguments (max is {0}).", MAXFIELDS);
            return;
        }
        
        for (int i=1; i<args.Length; i++)
        { cids[i-1] = int.Parse(args[i]); cidsize += 1; }
        
        // ------------------------------------------------------------------------------ //
        // Printing the list of arguments.                                                //
        // ------------------------------------------------------------------------------ //
        
        Console.WriteLine("Command line arguments are:");
        for (int i=0; i<args.Length; i++)
        { Console.WriteLine("\targs[{0}] = {1}", i, args[i]); }

        // ------------------------------------------------------------------------------ //
        // The previous action could also be coded using the "foreach" control:           //
        //    {                                                                            //
        //        int i=0;                                                                //
        //        foreach (string str in args)                                            //
        //        { Console.WriteLine("\tArgs[{0}] = {1}", i++, str); }                   //
        //    }                                                                            //
        // ------------------------------------------------------------------------------ //

        // ------------------------------------------------------------------------------ //
        // Open the input text file.                                                      //
        // ------------------------------------------------------------------------------ //
                
        try { inputfd = new StreamReader(args[0]); }
        catch (Exception ex)
        {
            Console.WriteLine(ex.ToString());
            return;
        }

        // ------------------------------------------------------------------------------ //
        // Read line per line, until the end of file.                                     //
        // ------------------------------------------------------------------------------ //    

        while (true)
        {
            string line = null;
            string[] columns = {}; // Arrays are delimited using characters "{" and "}"
            
            // ------------------------------------------------------------------------- //    
            // Read one line.                                                            //
            // ------------------------------------------------------------------------- //    

            line = inputfd.ReadLine();
            if (line == null) { break; }
            
            // ------------------------------------------------------------------------- //    
            // Split line using spaces as separator                                      //
            // ------------------------------------------------------------------------- //    

            columns = line.Split(' ');
            
            // ------------------------------------------------------------------------- //    
            // Show the select columns                                                   //
            // ------------------------------------------------------------------------- //    
            
            for (int i=0; i<cidsize; i++) { Console.Write("{0};", columns[i]); }
            Console.WriteLine("");
        }
        
        inputfd.Close();
    }
}

Les exceptions

using System;
using System.Text;

/// <summary>
/// The class is thrown whenever an error is detected in a given scenario.
/// </summary>

public class scenarioException : Exception
{
    /// <summary>
    /// Index of the line in the input scenario's description.
    /// </summary>

    public int my_lineNumber = 0;

    /// <summary>
    /// Line in the input scenario's description.
    /// </summary>

    public string my_lineText = null;

    /// <summary>
    /// Message that describes the error.
    /// </summary>

    public readonly string my_errorMessage = null;

    /// <summary>
    /// Create an exception.
    /// </summary>
    /// <param name="str"></param>

    public scenarioException(string inLocalErrorMessage)
    { my_errorMessage = inLocalErrorMessage; }

    /// <summary>
    /// Create the exception.
    /// </summary>
    /// <param name="inLocalErrorMessage">Message that describes the error.</param>
    /// <param name="inLocalLineNum">Index of the line in the input scenario's description.</param>
    /// <param name="inLocalLineText">Line in the input scenario's description.</param>

    public scenarioException(string inLocalErrorMessage, int inLocalLineNum, string inLocalLineText)
    {
        my_lineNumber = inLocalLineNum;
        my_lineText = inLocalLineText;
        my_errorMessage = inLocalErrorMessage;
    }
}

class scenario
{
	public scenario (string inName)
	{
		if (inName == "TEST") { throw new scenarioException("You can not call your scenario TEST."); }
	}
}

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {    
			try	{
					scenario sc = new scenario("TEST");
				}
			catch (scenarioException e)
				{
					Console.WriteLine("Exception message is: " + e.my_errorMessage);
				}
        }
    }
}

Les expressions régulières

using System;
using System.IO;
using System.Collections;
using System.Text.RegularExpressions;


class Program
{
    static void Main(string[] args)
    {
        string str;
        string res;
        Regex exp;
        string[] list;
        Match m;
        
        // ------------------------------------------------------------------------------ //
        // Simple Perl/PHP like regular expressions                                       //
        // ------------------------------------------------------------------------------ //
        
        str = "nom.prenom@domain.fr";
        exp = new Regex(@"^\w[\w\.\-]*@\w[\w\.\-]*$");
        if (exp.IsMatch(str)) { Console.WriteLine("TEST 1: (Simple match): {0} matches email address regexp\n", str); }

        res = Regex.Replace (str, @"^\w[\w\.\-]*@(\w[\w\.\-]*)$", "$1");
        Console.WriteLine("TEST 2: (Simple replacement): {0} domain is: {1}\n", str, res);
        
        Console.WriteLine("TEST 3: (Simple Split): Source is [{0}], splitting using '@' as separator", str);
        list = Regex.Split(str, "@");
        foreach (string st in list) { Console.WriteLine("\t{0}", st); }
        
        Console.WriteLine("\nTEST 4: (Simple replacement): Source is [{0}], removing spaces", str);
        str = "  nom.prenom@domain.fr  ";
        res = Regex.Replace (str, @"^\s*(\w[\w\.\-]*@\w[\w\.\-]*)\s*$", "$1");
        Console.WriteLine("\tchoped({0}) = [{1}]", str, res);

        // ------------------------------------------------------------------------------ //
        // Extracting sub matches (Perl like $1, $2, ...)                                 //
        // The method Match matches all text that matches the regular expression (and not //
        // only the first text that matches).                                             //
        // ------------------------------------------------------------------------------ //
        
        Console.WriteLine("\nTEST 5: Test sur les parenthèses capturantes:");
        str = "nom.prenom@domain.fr";
        Console.WriteLine("\tSource is [{0}]", str);
        exp = new Regex(@"^(\w[\w\.\-]*)@(\w[\w\.\-]*)$");
        m = exp.Match(str);
        if (m.Success)
        {
            // Note: m.Groups[0] represents the entire match (same that m.Value)
            //       m.Groups[1] represents the first parenthese
            //       m.Groups[2] represents the second parenthese
            Group g0 = m.Groups[0];
            Group g1 = m.Groups[1];
            Group g2 = m.Groups[2];
            Console.WriteLine("\tEntire match is [{0}] (index={1} / length={2})", g0.Value, g0.Index, g0.Length);
            Console.WriteLine("\tFist sub match is [{0}] (index={1} / length={2})", g1.Value, g1.Index, g1.Length);
            Console.WriteLine("\tSecond sub match is [{0}] (index={1} / length={2})", g2.Value, g2.Index, g2.Length);
        }

        // ------------------------------------------------------------------------------ //
        // Extracting sub matches (Perl like $1, $2, ...)                                 //
        // ------------------------------------------------------------------------------ //
        
        Console.WriteLine("\nTEST 6: Test sur les parenthèses capturantes:");
        str = "nom.prenom@domain.fr    nom1.prenom1@domain.fr1";
        Console.WriteLine("\tSource is [{0}]", str);
        exp = new Regex(@"(\w[\w\.\-]*)@(\w[\w\.\-]*)");
        m = exp.Match(str);
        while(m.Success)
        {
            Group g0 = m.Groups[0];
            Group g1 = m.Groups[1];
            Group g2 = m.Groups[2];
            Console.WriteLine("\t* Entire match is [{0}] (index={1} / length={2})", g0.Value, g0.Index, g0.Length);
            Console.WriteLine("\t  Fist sub match is [{0}] (index={1} / length={2})", g1.Value, g1.Index, g1.Length);
            Console.WriteLine("\t  Second sub match is [{0}] (index={1} / length={2})", g2.Value, g2.Index, g2.Length);
            m = m.NextMatch();
        }
        
        // ------------------------------------------------------------------------------ //
        // Named groups                                                                   //
        // ------------------------------------------------------------------------------ //
        
        str = "nom.prenom@domain.fr";
        exp = new Regex(@"^(?<login>\w[\w\.\-]*)@(?<domain>\w[\w\.\-]*)$");
        m = exp.Match(str);
        if (m.Success)
        {
            string name;
            string value;
            Console.WriteLine("\nTEST 7: Using named groups");
            
            // Warning GroupNameFromNumber() is a method from Regex (not Groups)
            name = exp.GroupNameFromNumber(1);
            value = m.Groups[1].Value;
            Console.WriteLine("\tname={0} and value={1}", name, value);

            name = exp.GroupNameFromNumber(2);
            value = m.Groups[2].Value;
            Console.WriteLine("\tname={0} and value={1}", name, value);
        }
        
        // ------------------------------------------------------------------------------ //
        // Using named groups with hash tables                                            //
        // ------------------------------------------------------------------------------ //
        
        Console.WriteLine("\nTEST 8: Using named groups with hash tables");
        str = "nom.prenom@domain.fr    nom.prenom1@domain1.fr";
        Console.WriteLine("\tSource is [{0}]", str);
        exp = new Regex(@"(?<login>\w[\w\.\-]*)@(?<domain>\w[\w\.\-]*)");
        m = exp.Match(str);
        
            // ------------------------------------------------------------------------- //
            // Building a hash table with couples (name => value)                        //
            // Hash keys are groups' names (ie: "login", "domain")                       //
            // Hash values are list of values (ie: the matched values)                   //
            // ------------------------------------------------------------------------- //

        // Fill hash table with extracted values
        Hashtable groups = new Hashtable();
        while(m.Success)
        {
            foreach (string name in exp.GetGroupNames())
            {
                if (! groups.ContainsKey(name)) { groups.Add (name, new ArrayList()); };
                int index = exp.GroupNumberFromName(name);
                ArrayList values = (ArrayList)groups[name];
                values.Add(m.Groups[index].Value);
            }
            m = m.NextMatch();
        }
        
        // Print all logins
        Console.WriteLine("\tLogins are:");
        foreach (string value in (ArrayList)groups["login"]) { Console.WriteLine ("\t\t{0}", value); }
        
        // Print all domains
        Console.WriteLine("\tDomains are:");
        foreach (string value in (ArrayList)groups["domain"]) { Console.WriteLine ("\t\t{0}", value); }
        
        // ------------------------------------------------------------------------------ //    
        // IDictionaryEnumerator en = groups.GetEnumerator();                             //
        // while (en.MoveNext())                                                          //
        // {                                                                              //
        //     string key = en.Key.ToString();                                              //
        //     ArrayList values = (ArrayList)groups[key];                                   //
        //     Console.WriteLine ("\t* {0}:", key);                                         //
        //     foreach (string value in values) { Console.WriteLine("\t\t{0}", value); }    //
        // }                                                                              //
        // ------------------------------------------------------------------------------ //    

    }
}

using System;
using System.IO;
using System.Collections;
using System.Text.RegularExpressions;

/// <summary>
/// This class simplifies the use of named regular expressions. Matches are directly accessible used their names.
/// It could easily be improved.
/// </summary>

public class extendedRegExp : Regex
{
    private Regex reg = null;
    private Hashtable groups = null;

    /// <summary>
    /// Create an extended regular expression.
    /// </summary>
    /// <param name="inMask">Regular expression.</param>
    /// <param name="inOption">Maching option.</param>

    public extendedRegExp(string inMask, RegexOptions inOption)
    {
        reg = new Regex(inMask, inOption);
    }

    /// <summary>
    /// Apply the regular expression.
    /// </summary>
    /// <param name="inText">Text that will be evaluated against the regular expression.</param>
    /// <returns>If the input text matches the regular expression, the the method returns the value "true". Otherwise, the method returns the value "false".</returns>

    public new bool Match(string inText)
    {
        Match m = null;

        m = reg.Match(inText);
        if (!m.Success) { return false; }
        groups = new Hashtable();

        while (m.Success)
        {
            foreach (string name in reg.GetGroupNames())
            {
                if (!groups.ContainsKey(name)) { groups.Add(name, new ArrayList()); };
                int index = reg.GroupNumberFromName(name);
                ArrayList values = (ArrayList)groups[name];
                values.Add(m.Groups[index].Value);
            }
            m = m.NextMatch();
        }

        return true;
    }

    /// <summary>
    /// Return the value of a given match, if it exists.
    /// If the regular expression returns several values for the same match, then values are stored into an array.
    /// </summary>
    /// <param name="inName">Name of the match.</param>
    /// <param name="inIndex">If the regular expression returns several values for the same match, this argument defines the order of the match you want to retrieve.</param>
    /// <param name="outExists">If the regular expression returns several values for the same match, you specify the order of the match you want to retrieve. If the order's value exceeds the total number of matches, then the method sets this parameter's value to "false".</param>
    /// <returns>If the requested match exists, then the method returns the matched value (and outExists is set to "true"). Otherwise, the method returns an empty string (and outExists is set to "false"). This means that the specified order exceeds the total number of matches.</returns>
    /// <exception>
    /// If the match's name is not defined (in the regular expression), then the method throws an exception.
    /// </exception>

    public string getMatch(string inName, int inIndex, ref bool outExists)
    {
        if (!groups.ContainsKey(inName)) { throw (new Exception("extendedRegExp: unknown match " + inName)); }
        if (((ArrayList)groups[inName]).Count <= inIndex) { outExists = false; return ""; }
        outExists = true;
        return (string)((ArrayList)groups[inName])[inIndex];
    }

    /// <summary>
    /// Return the value of a given match, if it exists.
    /// </summary>
    /// <param name="inName">Name of the match.</param>
    /// <returns>The method returns the matched value</returns>
    /// <remarks>
    /// You should call this method if you know that there is only one matched value (for the given match's name).
    /// </remarks>

    public string getMatch(string inName)
    {
        if (!groups.ContainsKey(inName)) { throw (new Exception("extendedRegExp: unknown match " + inName)); }
        return (string)((ArrayList)groups[inName])[0];
    }
}

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {    
			string txt1 = "Dupond Laurent 0123456789";
			string txt2 = "01 23 45 69 74";
			extendedRegExp coordonnees = new extendedRegExp(@"(?<prenom>[a-z]+)\s+(?<nom>[a-z]+)\s+(?<telephone>\d{10})",   RegexOptions.IgnoreCase);
			extendedRegExp digit       = new extendedRegExp(@"(?<digit>\d{2})",   RegexOptions.IgnoreCase);
		
			if (coordonnees.Match(txt1)) { Console.WriteLine("OK nom=" + coordonnees.getMatch("nom") + " premon=" + coordonnees.getMatch("prenom") + " tel=" + coordonnees.getMatch("telephone")); }
			if (digit.Match(txt2))
			{
				int i = 0;
				while (true)
				{
					bool c   = false;
					string d = null;
					d = digit.getMatch("digit", i, ref c);
					if (!c) { break; }
					Console.WriteLine(i + " " + d);
					i++;
				}
			}
		}
    }
}

Les sockets

using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Collections;
using System.Net.NetworkInformation;
using System.Text.RegularExpressions;




class Program
{
    private static byte[] StrToByteArray(string str)
    {
        System.Text.ASCIIEncoding  encoding=new System.Text.ASCIIEncoding();
        return encoding.GetBytes(str);
    }
    
    private static string ByteArrayToStr(byte[] buffer)
    {
        // System.Text.Encoding encoding = System.Text.Encoding.ASCII;
        System.Text.ASCIIEncoding  encoding=new System.Text.ASCIIEncoding();
        return encoding.GetString(buffer);
    }

    static void Main(string[] args)
    {
        string domain_name;
        string cgi_path;
        int port_number;
        int MAXSIZE = 1024;
        string response = "";
                
        // Parse the command line
        if (args.Length != 3)
        {
            Console.WriteLine("Usage: nettest <host name> <port number> <path to CGI>");
            return;
        }
        
        domain_name = args[0];
        port_number = Convert.ToInt32(args[1]);
        cgi_path    = args[2];
    
        // Create the socket
        Socket sck = new Socket    (AddressFamily.InterNetwork,
                                SocketType.Stream,
                                ProtocolType.Tcp);
    
        try {
                // Open connection to HTTPserver
                sck.Connect (new IPEndPoint(Dns.Resolve(domain_name).AddressList[0],port_number));
                
                // Send the GET request    
                sck.Send(StrToByteArray("GET " +  cgi_path + " HTTP/1.0\n"));
                sck.Send(StrToByteArray("Accept: */*\n"));
                sck.Send(StrToByteArray("\n\n"));
                
                // Read the server's response (read until the input buffer is empty)
                while (true)
                {
                    byte[] bytes = new byte[MAXSIZE];
                    int n = sck.Receive(bytes);
                    if (n == 0) { break; }
                    response += ByteArrayToStr(bytes);
                    if (n < MAXSIZE) { break; }
                }
            }
        catch (SocketException e)
        {
            Console.WriteLine("ERROR: Can not open connection - {0}.", e.ErrorCode);
            return;
        }
        
        // Write server's reponse
        Console.Write(response);
        
        // Fermeture de la connection
        sck.Shutdown(SocketShutdown.Both);
    }
}

Les threads

// See http://emerica.developpez.com/csharp/threads/

using System;
using System.Threading;

public class CThread
{
	private int my_loopNumber;
	
	public CThread (int loopNumber) { my_loopNumber = loopNumber; }
	public void ThreadLoop()
	{
		while (Thread.CurrentThread.IsAlive)
		{
			Console.WriteLine("Running " + my_loopNumber);
			Thread.Sleep(300);
		}
	}
}

class Program
{
    static void Main(string[] args)
    {
		// Pass parameters to the thread.
		CThread myThread = new CThread(10);
		
		// Create the thread
		Thread t = new Thread(new ThreadStart(myThread.ThreadLoop));
		
		// Start the thread
		t.Start();
		
		// The "main" process is a thread
		Console.WriteLine("main: sleep(2s)");
		Thread.Sleep(2000);
		
		// Suspend the thread
		Console.WriteLine("main: Suspend the thread.");
		t.Suspend();
		
		// Restart the shread
		Console.WriteLine("main: Restart the thread.");
		t.Resume();

		Console.WriteLine("main: sleep(1s)");
		Thread.Sleep(1000);
		
		// Destroy the thread
		Console.WriteLine("main: Aborting the thread");
		t.Abort();
	}
}