Discussion :

[langloiso]

Bonjour.

Voila mon problème :
j'ai développé une application en C# (sans paramètre de lancement) et je souhaiterai pouvoir la lancer via une commande msdos tout en passant des paramètres de démarrage.

En gros, mon exécutable s'appelle : MonProjet.exe
Pour le lancer j'utilise une commande msdos et tape : C:\ ... \MonProjet.exe
Et je souhaiterai pouvoir la lancer avec des plusieurs paramètres; du genre :
C:\ ... \MonProjet.exe [Parametre1] [Paramètre2]

Est ce que quelqu'un connaitrai les méthodes pour implémenter cela dans mon projet en C# pour que celui-ci, au démarrage :

1 - récupérer les paramètres tapés dans la commande msdos externe
2 - Utiliser les paramètres comme variable dans mon projet

Merci d'avance pour votre aide

[Guulh]

Hello,

t'as tout ce qu'il faut là : Environment.GetCommandLineArgs()

Après, tu peux créer un fichier .bat (ou .cmd), ou même un raccourci vers ton exe, avec les paramètres que tu veux.

[Philippe Vialatte]

Salut,

tu as un mecanisme de recuperation des arguments de ligne de commande qui correspond a ce qui existe, par exemple, en C

http://msdn.microsoft.com/fr-fr/libr...8VS.80%29.aspx

[langloiso]

Merci pour vos reponses!

J'ai déjà croisé, lors de mes précédentes recherches, ces deux méthodes...
Après les avoir testées, je me suis rendu compte, qu'elles n'étaient valables que en local (au niveau logiciel). Sauf erreur de ma part !

En tout cas, je n'arrive toujours pas a lire les lignes de commande tapées dans la fenêtre msdos (fenêtre dos normal de windows, indépendante de mon appli).

Si vous avez d'autres idées ou que l'erreur viens de mon côté, je suis preneur!

merci!

[Guulh]

Je comprends pas ton souci.

Si, en ligne de commande, tu tapes TonProgramme.exe blabla bloblo, tu récupères dans le programme lui même un tableau contenant blabla et bloblo.

Cette ligne de commande peut être directement tapée à la main dans cmd.exe (le prompt windows), ou bien dans un fichier de commande (bat ou cmd), ou dans un raccourci windows (fichier lnk).

Que veux-tu dire quand tu écris que ces méthodes "ne sont valables qu'en local" ?

Et tant que j'y suis : le dos, ça existe plus

[langloiso]

Re coucou^^

Bon alors, pour ce qui est de récupérer la commande de lancement de l'application, je crois que j'ai trouvé. je posterai la solution si cela fonctionne!

Par contre, mon deuxième soucis, c'est d'ajouter des paramètres de lancement dans mon appli. J'ai tenté de les ajouter comme en C dans le Main (cf. code ci dessous) mais je ne peux plus compiler car ma méthode n'est plus statique...

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
namespace TH_VIEW_Project
{
    static class Program
    {
        /// <summary>
        /// Point d'entrée principal de l'application.
        /// </summary>
        [STAThread]
 
        static void Main( string param1, string param2)
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new Window());
        }
    }
}

Comment puis-je donc ajouter, par exemple, deux paramètres de type "string" pour pouvoir avoir en commande de lancement :
C:\ ... \MonProjet.exe param1 param2

[EDIT]

Je viens de tester avec le code suivant :

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
namespace TH_VIEW_Project
{
 
    static class Program
    {
        /// <summary>
        /// Point d'entrée principal de l'application.
        /// </summary>
        [STAThread]
 
        static void Main( string[] args)
        {
            if (args.Length > 0)
            {
                //Pour chaque argument... On l'affiche.
                foreach (string argument in args)
                    MessageBox.Show("Argument : " + argument);
            }
            else
                MessageBox.Show("Vous n'avez pas passé d'arguments !");
 
 
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new Window());
        }
    }
}

Maintenant, je n'ai plus de problème de compilation. Par contre, je ne sais pas trop comment faire en sorte que mon programme prenne en compte mon parametre. Je le lance via une fenetre msdos : "C:\ ... \MonProjet.exe" -toto

Malheureusement, ma fonction retourne a chaque fois qu'il n'y a pas d'argument!

merci

[Max]

Salut.

Un main "standard" :

Code :

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

1
2
3
static void Main (string[] args) {
     ///...
}

où args contient la liste de tous les arguments que tu as pu passer en paramètre

Si tu lances ton programme avec cette ligne C:\ ... \MonProjet.exe param1 param2, args[0] contiendra param1, args[1] param2, etc.

[Kaidan]

Le raccourci via le Main ne fonctionne que si tu es en application "console".

En WinForms, il faut utiliser la méthode proposée par Guulh:

Code :

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

1
2
3
4
5
6
7
8
 
        [STAThread]
        static void Main()
        {
            string[] args = Environment.GetCommandLineArgs();
            if (args.Length > 0)
            {
            ...

[langloiso]

Bon ça ne veux pas fonctionner. Pourriez vous si possible, me répondre avec un bout de code a titre d'exemple fonctionnel pour le principe suivant :

1 - je créé un raccourci
2 - cible du raccourci = "c:\ ... \ MonProjet.exe" parametre1 parametre2
3 - récupérer mes deux paramètres respectivement dans param1, param2 (cf. code ci dessous)

ATTENTION : Comme précisé précédemment, mon application est en WinForms !

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
namespace TH_VIEW_Project
{
 
    static class Program
    {
        /// <summary>
        /// Point d'entrée principal de l'application.
        /// </summary>
        [STAThread]
 
        static void Main(string[] args)
        {
            args = Environment.GetCommandLineArgs();
            string param1 = args[0]; // je recupère mon parametre1
            string param2 = args[1]; // je récupère mon paramètre2
 
            if(args.Length >0)
            {
                MessageBox.Show("argument1 : ", param1);
                MessageBox.Show("argument1 : ", param2);
            }
            else
            {
                MessageBox.Show("pas d argument !");
            }
 
 
 
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new Window());
        }
    }
}

Encore désolé pour la gène occasionné et merci de votre patience!

[Guulh]

Et ? Ton bout de code marche pas ?

Par ailleurs, affecter Environment.GetCommandLineArgs() à args sert à rien. T'es dans le main, et args contient déjà les paramètres.