Discussion :

[tssi555]

Bonjour,

Je développe une application graphique en C#.
Serait t-il possible de combiner mode graphique / mode console surtout en passant deux paramètres au lancement (date début, date fin) en mode console même si l'application a été conçu en mode graphique à la base?

D'avance merci.

[Bluedeep]

Question beaucoup trop vague, même si la réponse est a priori "OUI".

Que veux tu faire exactement ?
Quel est le besoin fonctionnel ?

[StringBuilder]

J'ai l'impression que tu mélanges tout.

Tu as besoin d'avoir à la fois une fenêtre WinForm et une fenêtre Console ?
(sens du titre du topic)

Ou si tu as simplement besoin de récupérer les paramètres passés en paramètre à ton application ?
(sens 1 de ta question)

Ou si tu souhaite n'afficher une WinForm que si tu n'as pas de paramètres à ton application, et traiter en console sinon ?
(sens 2 de ta question)

Ou si tu veux autre-chose ?

La réponse est "oui" aux trois interprétations que j'ai de ton post.
Reste à savoir ce que tu veux vraiment afin d'éviter de s'amuser à te faire 3 exemple pour rien surtout si malgré mes 3 interprétations, c'est encore autre-chose que tu veux...

PS : Dans tous les cas, regarde du coté de la fonction Main dans le fichier Program.cs : il est très important, et répondra à chacune des interprétation que j'ai fait de ta question.

[tssi555]

Merci pour votre feedback rapide.

Pour moduler la question autrement :

J'ai une application WinForm, qu'on peut lancer via le fichier .exe. puis aller dans tel menu de l'MDI, charger la form en question, sélectionner deux dates, et appuyez sur le bouton qui fait la traitement entre la date de début et la date de fin.

Ce que j'aimerais faire :
Garder tjrs la possibilité de lancer l'application via le fichier .exe en mode graphique.
ET avoir la possibilité de lancer cette même application en mode console, en lui passant deux arguments (date début, date fin) au lancement, une fois les paramètres passés, le même traitement qu'en mode graphique se déclenchera.

J’espère avoir été claire cette fois-ci.

[Bluedeep]

Ok, là en effet la demande est claire.

Donc, tu as deux possibilités :

- la première :isoler ton traitement dans une assembly séparée dont une méthode d'entrée va recevoir les paramètres nécessaires au traitement et retourner les résultats éventuels.
Ensuite tu fais tout simplement deux exécutables : un en mode Console qui va récupérer les paramètres de commande et appeler la méthode en question, et un autre en mode "winform" qui va permettre la saisie des paramétres et appeler de la même façon la méthode.

- l'autre consiste à traiter dans le main de ton programme la présence de paramétres de ligne de commande et en fonction de cela appelere le traitement ou le show de la form en l'absence de paramètres d'entrée.
Pense que si tu pars d'un projet Winform il va falloir le modifier pour qu'il affiche éventuellement une console.

La première méthode est beaucoup plus propre.

[StringBuilder]

La première méthode est beaucoup plus propre.

C'est marrant, je trouve que c'est l'inverse : démultiplier les exe selon leur mode de fonctionnement j'ai l'impression de me retrouver avec MS-DOS et Windows 3.1, avec les programmes "undel" et "wundel" par exemple

Je trouve plus propre de tout avoir dans le même exe, à condition de le faire proprement : genre si on travaille en mode console, on n'ouvre pas de fenêtre en plein milieu.

[Bluedeep]

C'est marrant, je trouve que c'est l'inverse : démultiplier les exe selon leur mode de fonctionnement j'ai l'impression de me retrouver avec MS-DOS et Windows 3.1, avec les programmes "undel" et "wundel" par exemple

Mouais, là on rentre dans les préférences perso. Disons donc que je ne partage pas vraiment ton opinion : le principe d'avoir un lanceur technique contextuel et une DLL métier commune indépendante du contexte d'utilisation(éventuellement "branchable" par la suite sur un service ou quoi que ce soit) me semble assez "sain" en termes de S.o.C

Mais c'est vrai qu'ici il ne s'agit que deux dates; donc pragmatiquement tu as raison

[tssi555]

Que ce soit l'une ou l'autre, merci beaucoup pour vos réponses.

En tout cas, la gestion d'arguments dans le Main me convient bien pour le moment.

[StringBuilder]

Comme je disais, dans le Main du Program.cs, tu as :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
static void Main()
{
    Application.EnableVisualStyles();
    Application.SetCompatibleTextRenderingDefault(false);
    Application.Run(new Form1());
}

Il faut rajouter la gestion des arguments de ligne de commande :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
static void Main(params string[] args)
{
    Application.EnableVisualStyles();
    Application.SetCompatibleTextRenderingDefault(false);
    Application.Run(new Form1());
}

Puis décider de ce que tu fais quand il y a des arguments :

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
 
        static void Main(params string[] args)
        {
            if (args.Length == 0)
            {
                Application.EnableVisualStyles();
                Application.SetCompatibleTextRenderingDefault(false);
                Application.Run(new Form1());
            }
            else
            {
                if (args.Length == 2)
                {
                    DateTime d1;
                    DateTime d2;
 
                    if (DateTime.TryParse(args[0], out d1) && DateTime.TryParse(args[1], out d2))
                    {
                        // Tu fais ton traitement sur des deux dates ici
                        return;
                    }
                }
                Console.WriteLine("Si vous voulez lancer le programme en mode console, il faut deux arguments au format date.");
            }
        }