Esempio n. 1
0
        private void opérationsSupprimerToolStripMenuItem_Click(object sender, EventArgs e)
        {
            IFabriqueCommande fab      = LesFabriques.GetInstance().FabriqueDe(m_articleCourant.GetType());
            ICommande         commande = fab.CréerCommandeSupprimer(m_articleCourant);

            commande.Exécuter();
        }
Esempio n. 2
0
        public void CompléterLeMenu(ToolStripMenuItem p_menu, EventHandler p_eh)
        {
            List <string> raccourcis_existants = new List <string>();

            foreach (IFabriqueCommande fab in LesFabriques.GetInstance())
            {
                string raccourci = TrouvéRaccourciUnique(fab.DescriptionDuType, raccourcis_existants);
                raccourcis_existants.Add(raccourci);
                var tsi = new ToolStripMenuItem(raccourci, null, p_eh);
                tsi.Tag = new FabriqueEtArticle(fab, null);
                tsi.ShowShortcutKeys = true;
                p_menu.DropDownItems.Add(tsi);
            }

            foreach (var article in Document.Instance.TroisDerniersArticles())
            {
                foreach (var fabrique in LesFabriques.GetInstance())
                {
                    string raccourci = TrouvéRaccourciUnique(fabrique.DescriptionDuType, raccourcis_existants);
                    raccourcis_existants.Add(raccourci);
                    var tsi = new ToolStripMenuItem(raccourci + " " + article.Motif, null, p_eh);
                    tsi.Tag = new FabriqueEtArticle(fabrique, article);
                    tsi.ShowShortcutKeys = true;
                    p_menu.DropDownItems.Add(tsi);
                }
            }
        }
Esempio n. 3
0
        public PileLimitée <ICommande> m_commandesRétablissbles = new PileLimitée <ICommande>(5); // Commandes pour le Retablir/Ctrl+Y

        private Document()
        {
            try
            {
                // Recuperer le document
                Récupérer();
                try
                {
                    // Connecter la base des données
                    RequeteSQL.Connecterbd(strAccessConn);
                    // Chaque fabrique crée les colonnes du type d'article associé dans la base de donnée
                    IEnumerator <IFabriqueCommande> fab = LesFabriques.GetEnumerator();
                    while (fab.MoveNext())
                    {
                        fab.Current.CréerCommandeSQLPourCréerColonnes(RequeteSQL.m_bd).Exécuter();
                    }
                }
                catch {
                    AvertirCritique("La lecture de « {0} » a échoué.\n" +
                                    "Le programme va continuer sans utiliser la base des données.\n" +
                                    "Les données sont toujours sauvegardées dans le document « {1} »",
                                    NomFichierBD, NomFichierPhilatélie);
                }
            }
            catch
            {
                AvertirCritique("La lecture de « {0} » a échoué.\n" +
                                "Le programme va s'arrêter.\n",
                                NomFichierPhilatélie);

                Environment.Exit(0);  // Permet d'arrêter le programme directement.
            }
        }
Esempio n. 4
0
 public static LesFabriques GetInstance()
 {
     if (Instance is null)
     {
         Instance = new LesFabriques();
     }
     return(Instance);
 }
Esempio n. 5
0
        private void opérationsSupprimerToolStripMenuItem_Click(object sender, EventArgs e)
        {
            var fab      = LesFabriques.FabriqueDe(m_articleCourant.GetType());
            var commande = fab.CréerCommandeSupprimer(m_articleCourant);

            if (commande.Exécuter())
            {
                m_commandesAnnulables.Empiler(commande);
            }
        }
Esempio n. 6
0
        public static ArticlePhilatélique ArticleSelonNumero(int p_numero)
        {
            string type = BdScalar.Get <string>(m_bd,
                                                "SELECT type " +
                                                "FROM Articles " +
                                                "WHERE numero=?", p_numero);

            // Obtenir la bonne fabrique
            IFabriqueCommande f = LesFabriques.TrouverFabrique(type);
            // Obtenir la commande sql du type à chercher
            CommandeLireSQL cmdLireArticle = (CommandeLireSQL)f.CréerCommandeSQLPourLireArticle();
            // Obtenir l'article avec la bonne commande sql
            ArticlePhilatélique article = cmdLireArticle.ExecuterSQLLireArticle(m_bd, p_numero);

            return(article);
        }
Esempio n. 7
0
        public static void CompléterLeMenu(ToolStripMenuItem p_menu, EventHandler p_eh)
        {
            IEnumerator <IFabriqueCommande> f = LesFabriques.GetEnumerator();

            f.MoveNext();
            string descriptionPourMenu;

            while (f.Current != null)
            {
                descriptionPourMenu = TrouverNomPourMenuItems(f.Current.DescriptionPourMenu());

                var tsi = new ToolStripMenuItem(descriptionPourMenu, null, p_eh);
                tsi.Tag = f.Current;
                p_menu.DropDownItems.Add(tsi);
                descriptionPourMenu = "";
                f.MoveNext();
            }
        }
Esempio n. 8
0
        /// <summary>
        /// Ajouter un Article à la base de donnée
        /// </summary>
        /// <param name="p_article"></param>
        /// <returns>true quand operation reussit, false sinon</returns>
        public static bool AjouterArticle(ArticlePhilatélique p_article)
        {
            // Obtenir la bonne fabrique
            IFabriqueCommande f = LesFabriques.FabriqueDe(p_article.GetType());
            CommandeEcrireSQL cmdEcrireArticle = (CommandeEcrireSQL)f.CréerCommandeSQLPourEcrireArticle();

            // Executer le sql correspondant à l'article
            try
            {
                return(cmdEcrireArticle.ExecuterSQLEnregistrerArticle(m_bd, p_article));
            }
            catch (Exception e)
            {
                MB.AvertirCritique("Article ne peut etre ajouté à la base des données. « {0} ».",
                                   e.Message);
                return(false);
            }
        }
Esempio n. 9
0
 /// <summary>
 /// Renvoie tous les artiles.
 /// </summary>
 /// <returns>Toutes les productions.</returns>
 public static IEnumerable <ArticlePhilatélique> ToutesLesArticles()
 {
     using (BdReader bdr = new BdReader(m_bd,
                                        "SELECT type, numero " +
                                        "FROM Articles " +
                                        "ORDER BY type"))
     {
         while (bdr.Read())
         {
             // Obtenir la bonne fabrique
             IFabriqueCommande f = LesFabriques.FabriqueDe(Type.GetType(bdr.GetString(0)));
             // Obtenir la commande sql du type à chercher
             CommandeLireSQL cmdLireArticle = (CommandeLireSQL)f.CréerCommandeSQLPourLireArticle();
             // Obtenir l'article avec la bonne commande sql
             ArticlePhilatélique article = cmdLireArticle.ExecuterSQLLireArticle(m_bd, bdr.GetInt32(1));
             yield return(article);
         }
     }
 }
Esempio n. 10
0
        public static void CompléterLeSousMenu(ToolStripMenuItem p_menu, EventHandler p_eh)
        {
            IFabriqueCommande f = null; // fabrique qui correspond a item
            IEnumerable <ArticlePhilatélique> derniersArticles = Document.Instance.TousLesArticles();

            foreach (ToolStripMenuItem i in p_menu.DropDownItems)
            {
                IEnumerator <IFabriqueCommande> fs = LesFabriques.GetEnumerator();
                List <string> motifsExistants      = new List <string>();

                fs.MoveNext();
                bool continuer = true;
                while (fs.Current != null && continuer)
                {
                    string nomType = i.Tag.GetType().ToString();
                    f = LesFabriques.TrouverFabrique(nomType);
                    if (f != null)
                    {
                        break;
                    }
                    fs.MoveNext();
                }

                foreach (var article in Document.Instance.TousLesArticles().Reverse())
                {
                    if (!motifsExistants.Contains(article.Motif))
                    {
                        string descriptionPourMenu = TrouverNomPourMenuItems(f.DescriptionPourMenu() + " " + article.Motif);
                        motifsExistants.Add(article.Motif);
                        var tsi = new ToolStripMenuItem(descriptionPourMenu, null, p_eh, article.Motif + "@" + article.Parution);
                        tsi.Tag = f;
                        i.DropDownItems.Add(tsi);
                    }
                }
            }
        }
Esempio n. 11
0
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            // « LesFabriques » est une classe qui gère les fabriques (Abstract Factory) de commandes (surtout).
            // Chaque type de produit philatélique aura sa fabrique pour créer les diverses commandes
            // nécessaires pour ce type (ainsi que la description du type de produit). Il faut une clef pour
            // identifier la fabrique nécessaire, et on veut pouvoir obtenir cette clef à partir d'un article
            // philathélique. Au lieu de créer une méthode virtuelle pour donner le nom du type, ou un autre
            // code, on se sert du System.Type des classes, accessible en général par typeof(), mais aussi à
            // partir d'une donnée par la méthode GetType() (qui renvoie le vrai Type de l'instance et non de
            // la référence elle-même, ce que ferait typeof() dans ce contexte).
            LesFabriques.GetInstance().Ajouter(typeof(TimbreSeul), FabriqueTimbreSeul.Instance);
            LesFabriques.GetInstance().Ajouter(typeof(BlocDeCoin), FabriqueBlocDeCoin.Instance);
            // N.B. Si on voulait rendre le programme plus clair pour les humains, on pourrait utiliser la
            //      propriété .FullName sur les valeurs de type Type : on pourrait ainsi avoir un Dictionary
            //      dont la clef serait une string au lieu d'une valeur de type Type. Mais ce serait juste
            //      une opération de plus, pas plus utile en général...

            // Si on ajoute des classes dérivées de ArticlePhilatélique, il suffit de mettre les fichiers
            // dans le projet et d'ajouter un instruction pour ajouter la fabrique du nouveau type.
            // LesFabriques.Ajouter(typeof(PliPremierJourOfficiel_), FabriquePliPremierJourOfficiel_.Instance);

            // Ou encore, pour n'avoir rien du tout à changer au programme, on peut faire des dll séparés qui
            // seront chargés ici automatiquement :
            var lesDll = System.IO.Directory.GetFiles(@"..\..\..", "AP-*.dll");

            foreach (var nomDLL in lesDll)
            {
                var dll = Assembly.LoadFrom(nomDLL);

                // On regarde s'il y a un type dérivé de ArticlePhilatélique
                Type typePourArticle = dll.GetExportedTypes()
                                       .FirstOrDefault(t => t.BaseType == typeof(ArticlePhilatélique));

                // Si oui, on cherchera une fabrique
                if (typePourArticle != null)
                {
                    // On cherche une fabrique (classe qui implémente IFabriqueCommande)
                    Type typePourFabrique = dll.GetExportedTypes()
                                            .FirstOrDefault(t => t.GetInterface("IFabriqueCommande") != null);

                    // Si on a un type et une fabrique, on va ajouter ça à LesFabriques
                    if (typePourFabrique != null)
                    {
                        // On cherche la propriété pour créer le singleton
                        var propriétéInstance = typePourFabrique.GetProperty("InstanceFabrique");

                        if (propriétéInstance != null)  // Ça devrait !
                        {
                            // On exécute la propriété pour créer le singleton
                            var fabrique = (IFabriqueCommande)propriétéInstance.GetValue(null);
                            LesFabriques.GetInstance().Ajouter(typePourArticle, fabrique);
                        }
                    }
                }

                // Bonne référence avec exemples simples pour la réflexion :
                // http://www.csharp-examples.net/reflection-examples/
            }

            Application.Run(new FormPrincipal());
        }