//LA FONCTION PRINT QUI PERMET DE LIRE UN AUTOMATE DEPUIS UN FICHIER TEXTE
        public static AFD read(string chemin)
        {
            int  j;                 // COMPTEUR QUI RECOIT LES CARACTERE ASCII EN INT
            char c;                 // CARACTERE QUI RECOIT LE SYMBOLE D'UNE TRANSITION
            AFD  AUTOM = new AFD(); // L'AFD A REMPLIR ET A RETOURNER

            // LECTURE DU LA CHIAINE OU SE TROUVE L'AUTOMATE
            using (StreamReader sr = new StreamReader(chemin))
            {
                string      ligne;                                   // LA CHAINE QUI REPRENSTERA LE FICHIER AFD
                int         curs     = 1;                            // CURSEUR QUI DEFINIRAIT A QUOI CORRESPOND CHAQUE LIGNE
                List <char> Alphabet = new List <char>();            // LISTE DE CARACTERES DE L'ALPHABET
                AUTOM.setAlphabet(Alphabet);                         // ALLOUER A L'ATTRIBUT ALPHABET UN ESPACE MEMOIRE CREE PAR LA LISTE ALPHABET
                List <int>        EFinaux = new List <int>();        // LISTE D'ENTIERS DES ETATS FINAUX DANS LAQUELLE ON VA INSERER NOS ETATS FINAUX
                List <Transition> Tr      = new List <Transition>(); // LISTE DE TRANSITION OU ON VA AJOUTER CHAQUE FOIS ON CREE UNE NOUVELLE TRANSITION
                Transition        t       = new Transition();        // INTACIATION D'UN OBJET DE TYPE TRANSITION
                while ((ligne = sr.ReadLine()) != null)
                {
                    // RENITIALISATION DE L'OBJET TRANSITION ...
                    t = new Transition();
                    switch (curs)
                    {
                    // REMPLISSAGE DE L'ATTRIBUT nbrEtat
                    case 1:
                        AUTOM.setNbrEtat(Int16.Parse(ligne));
                        break;

                    // REMPLISSAGE DE L'ALPHABET DE L'AFD
                    case 2:
                        // SEPARATION DES CARACTERE DE L'ALPHABET SACHANT QUE LES CARACTERE SONT SEPARE PAR DES ESPACES
                        // (ON PEUT LA MODIFIER SI ON VEUT QUE L'ALPHABET SOIT UNE SEULE CHAINE AVEC AUCUN ESPACE ENTRE LES CARACTERE DE L'ALPHABET)
                        string[] alph = ligne.Split(" ");

                        // BOUCLE QUI SE REPETE TANT QU'ON TROUVE DES ELEMENTS DANS LE TABLEAU D'ALPHABET
                        foreach (string al in alph)
                        {
                            AUTOM.getAlphabet().Add(char.Parse(al));
                        }
                        break;

                    // REMPLISSAGE DE L'ATTRIBUT etatInitial
                    case 3:
                        AUTOM.setEtatInitial(Int16.Parse(ligne));
                        break;

                    // REMPLISSAGE DE L'ATTRIBUT nbrEtatFinal
                    case 4:
                        AUTOM.setNbrEtatFinal(Int16.Parse(ligne));
                        break;

                    // REMPLISSAGE DE LA LISTE EFINAUX QUI CONTIENDERA L'ENSEMBLE D'ETAT FINAUX
                    case 5:
                        string[] EF = ligne.Split(" ");
                        foreach (string etat in EF)
                        {
                            EFinaux.Add(Int16.Parse(etat));
                        }
                        break;

                    // REMPLISSAGE DE LA LISTE DES TRANSACTIONS
                    default:
                        string[] trasac = ligne.Split(" ");
                        c = char.Parse(trasac[1]);
                        // LE SYMBLOE DE LA TRANSITION EST C --> CHIFFRE
                        if (c == 'C')
                        {
                            // BOUCLE QUI PARCOURS LES CODES ASCII DES CHIFFRES --> DE 0 à 9
                            for (j = 48; j <= 57; j++)
                            {
                                // DEFINITION D'UN NOUVEAU OBJET TRANSITION AFIN DE LUI AFFECTER LA NOUVELLE TRANSITION AVEC DES NOUVELLES VALEURS POUR LES ATTRIBUTS ( etatI - symbole - etatF )
                                t = new Transition();
                                t.setEtatI(Int16.Parse(trasac[0]));
                                t.setSymbole((char)j);
                                t.setEtatF(Int16.Parse(trasac[2]));
                                // AJOUTER LA NOUVELLE TRANSITION A LA LISTE DE TRANSITIONS
                                Tr.Add(t);
                            }
                        }
                        // LE SYMBLOE DE LA TRANSITION EST L --> LETTRE
                        if (c == 'L')
                        {
                            // BOUCLE QUI PARCOURS LES CODES ASCII DES LETTRE MAJ --> DE A à Z
                            for (j = 65; j <= 90; j++)
                            {
                                t = new Transition();
                                t.setEtatI(Int16.Parse(trasac[0]));
                                t.setSymbole((char)j);
                                t.setEtatF(Int16.Parse(trasac[2]));
                                Tr.Add(t);
                            }
                            // BOUCLE QUI PARCOURS LES CODES ASCII DES LETTRE MIN --> DE a à z
                            for (j = 97; j <= 122; j++)
                            {
                                t = new Transition();
                                t.setEtatI(Int16.Parse(trasac[0]));
                                t.setSymbole((char)j);
                                t.setEtatF(Int16.Parse(trasac[2]));
                                Tr.Add(t);
                            }
                        }
                        // LE SYMBLOE DE LA TRANSITION EST X --> IL S'AGIT DE N'IMPORTE QUOI DE L'AUTOMATE QUI LIT LES CHAINES DE CARACTERES
                        if (c == 'X')
                        {
                            // BOUCLE QUI PARCOURS LES CODES ASCII DE TOUT LE CLAVIER
                            for (j = 32; j <= 126; j++)
                            {
                                // SAUF LE CARACTERE " CAR IL Y A UNE TRANSITION UNIQUE AVEC CE SYMBOLE QUI PERMETTERA D'ALLER VERS UN ETAT FINAL AINSI DE SORTIR DE L'AUTOMATE
                                if (j != 34)
                                {
                                    t = new Transition();
                                    t.setEtatI(Int16.Parse(trasac[0]));
                                    t.setSymbole((char)j);
                                    t.setEtatF(Int16.Parse(trasac[2]));
                                    Tr.Add(t);
                                }
                            }
                        }
                        // LE SYMBLOE DE LA TRANSITION EST 1 --> PREMIER AUTRE, IL S'AGIT DU CODER TOUT LE CAS POSSIBLE DU CLAVIER POUR ALLER VERS UN ETAT FINAL
                        if (c == '1')
                        {
                            for (j = 32; j <= 126; j++)
                            {
                                // SAUF LE =
                                if (j != 61)
                                {
                                    t = new Transition();
                                    t.setEtatI(Int16.Parse(trasac[0]));
                                    t.setSymbole((char)j);
                                    t.setEtatF(Int16.Parse(trasac[2]));
                                    Tr.Add(t);
                                }
                            }
                        }
                        // LE SYMBLOE DE LA TRANSITION EST 2 --> DEUXIEME AUTRE, IL S'AGIT DU CODER TOUT LE CAS POSSIBLE DU CLAVIER POUR ALLER VERS UN ETAT FINAL
                        if (c == '2')    // autre 2
                        {
                            for (j = 32; j <= 126; j++)
                            {
                                // AUTRE: DIFFERENT DE = ET >
                                if (j != 61 && j != 62)
                                {
                                    t = new Transition();
                                    t.setEtatI(Int16.Parse(trasac[0]));
                                    t.setSymbole((char)j);
                                    t.setEtatF(Int16.Parse(trasac[2]));
                                    Tr.Add(t);
                                }
                            }
                        }
                        // LE SYMBLOE DE LA TRANSITION EST 3 --> TROISIEME AUTRE, IL S'AGIT DU CODER TOUT LE CAS POSSIBLE DU CLAVIER POUR ALLER VERS UN ETAT FINAL
                        if (c == '3')
                        {
                            for (j = 32; j <= 126; j++)
                            {
                                // AUTRE : DIFFERENT DES LETTRES ( MAJ- MIN ) ET LES CHIIFRES (0 à 9)
                                if ((j < 48) || (j > 57 && j < 65) || (j > 90 && j < 97) || (j > 122))
                                {
                                    t = new Transition();
                                    t.setEtatI(Int16.Parse(trasac[0]));
                                    t.setSymbole((char)j);
                                    t.setEtatF(Int16.Parse(trasac[2]));
                                    Tr.Add(t);
                                }
                            }
                        }
                        // LE SYMBLOE DE LA TRANSITION EST 4 --> QUATRIEME AUTRE, IL S'AGIT DU CODER TOUT LE CAS POSSIBLE DU CLAVIER POUR ALLER VERS UN ETAT FINAL
                        if (c == '4')
                        {
                            for (j = 32; j <= 126; j++)
                            {
                                // AUTRE : DIFFERENT DES CHIFFES ET DU .    => POUR LIRE SEUELEMENT LES ENTIERS
                                if ((j < 48 || j > 57) && j != 46)
                                {
                                    t = new Transition();
                                    t.setEtatI(Int16.Parse(trasac[0]));
                                    t.setSymbole((char)j);
                                    t.setEtatF(Int16.Parse(trasac[2]));
                                    Tr.Add(t);
                                }
                            }
                        }
                        // LE SYMBLOE DE LA TRANSITION EST 5 --> CINQUEME AUTRE, IL S'AGIT DU CODER TOUT LE CAS POSSIBLE DU CLAVIER POUR ALLER VERS UN ETAT FINAL
                        if (c == '5')
                        {
                            for (j = 32; j <= 126; j++)
                            {
                                // AUTRE : DIFFERENT DES CHIFFES ET DU CARACTERE 'E'    => POUR LIRE SEULEMENT LES FLOATS
                                if ((j < 48 || j > 57) && j != 69)
                                {
                                    t = new Transition();
                                    t.setEtatI(Int16.Parse(trasac[0]));
                                    t.setSymbole((char)j);
                                    t.setEtatF(Int16.Parse(trasac[2]));
                                    Tr.Add(t);
                                }
                            }
                        }
                        // LE SYMBLOE DE LA TRANSITION EST 6 --> SIXIEME AUTRE, IL S'AGIT DU CODER TOUT LE CAS POSSIBLE DU CLAVIER POUR ALLER VERS UN ETAT FINAL
                        if (c == '6')
                        {
                            for (j = 32; j <= 126; j++)
                            {
                                // AUTRE : DIFFERENT DES CHIFFES                    => POUR LIRE SEULEMENT LES REELS
                                if ((j < 48 || j > 57))
                                {
                                    t = new Transition();
                                    t.setEtatI(Int16.Parse(trasac[0]));
                                    t.setSymbole((char)j);
                                    t.setEtatF(Int16.Parse(trasac[2]));
                                    Tr.Add(t);
                                }
                            }
                        }
                        // LE SYMBLOE DE LA TRANSITION EST 7 --> SEPTIEME AUTRE, IL S'AGIT DU CODER TOUT LE CAS POSSIBLE DU CLAVIER POUR ALLER VERS UN ETAT FINAL
                        if (c == '7')
                        {
                            for (j = 32; j <= 126; j++)
                            {
                                // AUTRE : SAUF )                               => POUR LIRE UN COMMENTAIRE
                                if (j != 41)
                                {
                                    t = new Transition();
                                    t.setEtatI(Int16.Parse(trasac[0]));
                                    t.setSymbole((char)j);
                                    t.setEtatF(Int16.Parse(trasac[2]));
                                    Tr.Add(t);
                                }
                            }
                        }
                        // LE SYMBLOE DE LA TRANSITION EST N --> IL S'AGIT DE N'IMPORTE QUOI DE L'AUTOMATE QUI LIT LES CHAINES DE CARACTERES
                        if (c == 'N')
                        {
                            for (j = 32; j <= 126; j++)
                            {
                                // SAUF LE CARACTERE * CAR IL Y A UNE TRANSITION UNIQUE AVEC CE SYMBOLE QUI PERMETTERA D'ALLER VERS UN ETAT FINAL AINSI DE SORTIR DE L'AUTOMATE
                                if (j != 42)
                                {
                                    t = new Transition();
                                    t.setEtatI(Int16.Parse(trasac[0]));
                                    t.setSymbole((char)j);
                                    t.setEtatF(Int16.Parse(trasac[2]));
                                    Tr.Add(t);
                                }
                            }
                        }
                        // TOUT AUTRE SYMBOLE SERAIT DEFINIT COMME UNE TRANSACTION UNIQUE DE CE SYMBOLE ENTRE UN ETAT INITIAL ET FINAL
                        if (c != 'L' && c != 'C' && c != 'X' && c != '1' && c != '2' && c != '3' && c != '4' && c != '5' && c != '6' && c != 'N' && c != '7')
                        {
                            t = new Transition();
                            t.setEtatI(Int16.Parse(trasac[0]));
                            t.setSymbole(c);
                            t.setEtatF(Int16.Parse(trasac[2]));
                            Tr.Add(t);
                        }



                        break;
                    }
                    // INCREMENTATION DU CURSEUR QUI INDIQUE LA LIGNE
                    curs++;
                }
                AUTOM.setEtatFinaux(EFinaux); // REMPLISSAGE DE L'ATTRIBUR etatFinaux AVEC LA LISTE DEJA REMPLIE EFinaux
                AUTOM.setTransitions(Tr);     // REMPLISSAGE DE L'ATTRIBUR transitions AVEC LA LISTE DEJA REMPLIE Tr
            }
            return(AUTOM);                    // ON RETOURNE L'AUTOMATE COMPLET
        }
        //LA FONCTION PRINT QUI PERMET D'AFFICHER L'AUTOMATE AINSI QUE CES COMPOSANTS
        public static void print(AFD AUTOM)
        {
            // BOUCLE QUI PERMET D'AFFICHER LES DIFFERENTS ETATS (INITIAUX ET FINAUX)
            for (int i = 0; i < AUTOM.getNbrEtat(); i++)
            {
                if (i == 0)
                {
                    Console.Write("E=({0}", i); // LE PREMIER ETAT
                }
                else
                if (i == AUTOM.getNbrEtat() - 1)
                {
                    Console.WriteLine(",{0})", i); // LA DERNIERE ETAT
                }
                else
                {
                    Console.Write(",{0}", i); // LES AUTRES ETATS DU MILIEU
                }
            }
            // BOUCLE QUI PERMET D'AFFICHER L'ALPHABET DE L'AUTOMATE
            for (int i = 0; i < AUTOM.getAlphabet().Count; i++)
            {
                if (i == 0)
                {
                    Console.Write("A=({0}", AUTOM.getAlphabet()[i]); // LE PREMIER CARACTERE
                }
                else
                if (i == AUTOM.getAlphabet().Count - 1)
                {
                    Console.WriteLine(",{0})", AUTOM.getAlphabet()[i]); // LE DERNIER CARACTERE
                }
                else
                {
                    Console.Write(",{0}", AUTOM.getAlphabet()[i]); // LES AUTRES CARACTERES DE L'ALPHABET
                }
            }
            Console.WriteLine("Transactions:");
            // BOUCLE QUI PERMET D'AFFICHER LES TRANSACTIONS
            for (int i = 0; i < AUTOM.getTransitions().Count; i++)
            {
                Console.WriteLine("t({0},{1})={2}  ", AUTOM.getTransitions()[i].getEtatI(), AUTOM.getTransitions()[i].getSymbole(), AUTOM.getTransitions()[i].getEtatF());
            }

            // L'AFFICHAGE DE L'ETAT INITIAL
            Console.WriteLine("I= {0}", AUTOM.getEtatInitial());
            // L'AFFICHAGE DES ETATS FINAUX
            if (AUTOM.getNbrEtatFinal() == 1)
            {
                Console.WriteLine("F=({0})", AUTOM.getEtatFinaux()[0]); // SI IL S'AGIT D'UN SEUL ETAT FINAL
            }
            else
            {
                for (int i = 0; i < AUTOM.getNbrEtatFinal(); i++)
                {
                    if (i == 0)
                    {
                        Console.Write("F=( {0}", AUTOM.getEtatFinaux()[i]); // LE PREMIER ETAT FINAL
                    }
                    else
                    if (i == AUTOM.getNbrEtatFinal() - 1)
                    {
                        Console.WriteLine(", {0} )", AUTOM.getEtatFinaux()[i]); // LE DERNIER ETAT FINAL
                    }
                    else
                    {
                        Console.Write(", {0}", AUTOM.getEtatFinaux()[i]); // LES AUTRES ETATS FINAUX
                    }
                }
            }
            // L'AFFICHAGE DE NOMBRE DES TRANSACTIONS
            Console.WriteLine("Nombre de transactions : {0}", AUTOM.getTransitions().Count);
        }