Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C# Discussion :

Problème de passage entre formulaire


Sujet :

C#

  1. #1
    Membre régulier
    Problème de passage entre formulaire
    Bonjour à tous,
    je rencontre un petit problème qui me fait tourner en rond.
    J'ai un projet qui utilise de multiple fenêtres, j'aimerai avoir une classe avec une méthode qui me permettrait de faire un retour en arrière dans mes formulaires.
    je m'explique :
    j'ai un formulaire A qui ouvre un B, puis B qui ouvre un C et quand on ferme C on revient au formulaire A.
    j'ai ceci sur X branches.
    du coups j'aimerai avoir une méthode unique pour gérer le retour en arrière.
    j'ai bien fait ceci :
    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
     
            public static void OuvertureForm(Form RetourForm, string StrRetourForm)
                {
                RetourForm RechargementFormulaire = (RetourForm)Application.OpenForms[StrRetourForm];
     
                if (RechargementFormulaire != null)
                    {
                    RechargementFormulaire.SubReactualisationTableauBord();
     
                    RechargementFormulaire = null;
                    }
                else
                    {
                    RechargementFormulaire = null;
     
                    var withBlock = new RetourForm();
                    withBlock.Show();
     
                    withBlock = null;
                    }
                }

    mais cela me retourne un erreur "RetourForm : est un variable mais il est utilisé comme un Type" ... je comprend mais je ne sais pas comment contourner le problème.

    Quelqu'un pourrait-il m'aider ?

    Merci d'avance...
    Débutant un jour, débutant toujours car chaques jours qui passent nous en apprend un peu plus.

  2. #2
    Expert éminent
    Bonjour,
    Ton problème vient de là:
    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
     
     public static void OuvertureForm(Form RetourForm, string StrRetourForm)
                {
                RetourForm RechargementFormulaire = (RetourForm)Application.OpenForms[StrRetourForm];

    Tu déclares un paramètre qui s'appelle RetourForm(de type Form), puis dans la ligne en dessous tu déclares une variable RechargementFormulaire de type RetourForm.
    Sur la première ligne RetournForm est une variable, et sur la deuxième un type. Ce n'est pas possible, c'est soit l'un soit l'autre.

    Tatayo.

  3. #3
    Membre régulier
    re
    Bonsoir tatayo,

    c'est effectivement ce que j'ai compris mais du coups je ne sais pas comment je peux faire.

    aurais-tu une piste ?

    Cdt
    Débutant un jour, débutant toujours car chaques jours qui passent nous en apprend un peu plus.

  4. #4
    Expert éminent
    Le truc ici est que je ne sais pas ce que tu veux faire.
    Si le type RetourForm existe vraiment, il faut renommer le paramètre de la fonction.
    Sinon il faut regarder ce que renvoie la méthode Application.OpenForms[StrRetourForm]. Au hasard, le type ne serait pas Form ?
    Dans ce cas il faut modifier la ligne 4.
    En regardant le code et le nom des méthodes, je penche pour la deuxième hypothèse.
    Mais il y a un truc qui me chiffonne: pourquoi veux tu affecter une valeur au paramètre RetournForm ?
    Tel que ton code est écrit, je ne vois pas à quoi il peut bien servir.
    A moins que le but de ta fonction soit de renvoyer une instance de Form ?
    Dans ce cas je ferai ainsi:
    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
     
    public static Form OuvertureForm(string StrRetourForm) => (Form)Application.OpenForms[StrRetourForm];

    Je ne sais pas si (Form) est utile ici, je ne sais pas ce que renvoie Application.OpenForms[StrRetourForm].

    Tatayo.

  5. #5
    Membre régulier
    je me suis surement mal exprimé.
    En fait dans mon programme j'ai un max de formulaire.
    Mon arborescence est du type :
    Menu principal ->Form A ->FormC
    |->Form D->Form E
    |->Form F->Form G->FormH
    si je suis sur des formulaires C,E,G,H quand je les quittes j'ai besoin de ré ouvrir les précédents.
    Mais si je suis sur les Formulaire A,D,F j'ai besoin d'activer une méthode rafraîchissement du formulaire Menu principal.
    Donc sur chaque formulaire, dans le "this.FormClosed" j'ouvre ou je rafraîchis un autre formulaire.
    les lignes de codes sont en répétitions et à foison.
    je voulais donc créer un classe avec une méthode qui soit générique (Valable dans tous les cas).

    Je viens de trouver une solution.
    Elle est surement simplifiable mais elle à le mérite de fonctionner.
    A partir de deux string : NomDuFormulaire et de Methode(A exécuter si besoin), je navigue entre mes formulaires.
    voilà comment je viens de réussir à faire.
    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
     
    /// <summary>
            /// Navigation entre Formulaires.
            /// </summary>
            /// <param name="NomDuForm">Nom du form a ouvrir.</param>
            /// <param name="Methode">Methode a executer.</param>
            public void FormulairePrecedent(string NomDuForm,string Methode = "")
                {
                string NomAssemblyDuForm = "";
                //***************************************************************
                //** En fonction du nom du formulaire on récupére son assembly **
                //***************************************************************
                Assembly currentAssembly = Assembly.GetExecutingAssembly();
     
                foreach (Type objType in currentAssembly.GetExportedTypes())
                    {
                    if (objType.IsSubclassOf(typeof(Form)))
                        {
                        if (objType.Name == NomDuForm)
                            {
                            NomAssemblyDuForm = objType.Namespace + "." + objType.Name;
                            }
                        }
                    }
     
                if (NomAssemblyDuForm.Length != 0)
                    {
                    //** On déclare l'assembly **
                    Type myType = currentAssembly.GetType(NomAssemblyDuForm);
     
                    //** On déclare la méthode a éxécuter si il y en a une **
                    MethodInfo MethodeaExecuter = null;
     
                    if (Methode.Length != 0)
                        {
                        MethodeaExecuter = myType.GetMethod(Methode);
                        }
     
                    //** on vérifie si le form est déjà ouvert
                    if (Application.OpenForms.Cast<Form>().Any(form => form.Name == NomDuForm) == true)
                        {
                        //** si oui on récupére l'instance
                        object instance = Application.OpenForms[NomDuForm];
     
                        //** et on execute la méthode si elle existe
                        if (Methode.Length != 0)
                            {
                            MethodeaExecuter.Invoke(instance,null);
                            }
                        }
                    else
                        {
                        //** Sinon on crée une nouvelle instance de l'assembly du form
                        object instance = Activator.CreateInstance(myType);
     
                        //** On l'ouvre
                        ((Form)instance).Show();
     
                        //** et on execute la méthode si il y en as une 
                        if (Methode.Length != 0)
                            {
                            MethodeaExecuter.Invoke(instance,null);
                            }
                        }
     
                    }
                }


    Je suis preneur de toute simplification.

    Merci encore pour ta réflexion et ton aide...
    Débutant un jour, débutant toujours car chaques jours qui passent nous en apprend un peu plus.