Discussion :

[Feldunost]

Bonjour,


Étant un poil nouveau en C#, je me suis basé sur quelques dizaines de tutoriaux

Différentes méthodes étaient envisageables, mais j'ai pris celle de vôtre tutoriel qui est très complet.


J'aimerais cependant vôtre avis en ce qui concerne ceci:

Code :

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

1
2
3
4
5
6
7
8
private void BT_Launcher_Click(object sender, EventArgs e)
{
System.Diagnostics.Process proc = new System.Diagnostics.Process();
proc.StartInfo.Filename = "Client.exe";
proc.StartInfo.Arguments = "/P192.168.1.145:7442";
proc.Start();
proc.Close();
}

Si je souhaite intégrer le Client.exe en tant que ressource dans l'application C#, comment vais je faire pour lancer le processus si l'application est dans les ressources?

Sachant que l'application se lance en command line: "Client.exe /P192.168.1.145:7442"



En ce qui concerne le lancement du programme en fenêtré avec une taille définie en 1024*766 par exemple, j'ai trouvé ces commandes, cependant je ne parviens pas à trouver le moyen de régler la taille de la fenêtre.

Code :

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

1
2
    ProcessStartInfo* startInfo = new ProcessStartInfo(S"IExplore.exe");
    startInfo->WindowStyle = ProcessWindowStyle::Minimized;

Ainsi que :

Code :

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

1
2
(SetWindowPos(p.MainWindowHandle, HWND_TOP, 100, 100, 100, 100,
SWP_SHOWWINDOW) == 0)

Cependant y a t-il un moyen de gérer cela en mode graphique dans Visual C# ?



Merci pour cette information capitale pour ce projet !

[StormimOn]

Tu peux intégrer un fichier dans les ressources en tant que fichier binaire (ce qui sera le cas pour un exe par défaut je pense). La ressource sera alors sous la forme d'un tableau d'octets (byte[]).

Avant d'appeler ton exécutable tu dois ensuite écrire les données binaires sur le disque. Tu peux utiliser la méthode File.WriteAllBytes pour ça.

[Feldunost]

Tu peux intégrer un fichier dans les ressources en tant que fichier binaire (ce qui sera le cas pour un exe par défaut je pense). La ressource sera alors sous la forme d'un tableau d'octets (byte[]).

Avant d'appeler ton exécutable tu dois ensuite écrire les données binaires sur le disque. Tu peux utiliser la méthode File.WriteAllBytes pour ça.

L'intégration du fichier.exe en ressource a été faite, mais je n'ai pas compris en ce qui concerne l'écriture des données binaires sur le disque ... (Je regarderai de plus près le lien donné à mon retour)


En ce qui concerne le lancement du processus en fenêtré, est-ce possible réellement?

[StormimOn]

L'intégration du fichier.exe en ressource a été faite, mais je n'ai pas compris en ce qui concerne l'écriture des données binaires sur le disque

En gros tu dois faire quelque chose comme

Code :

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

System.IO.File.WriteAllBytes(@"X:\...\Client.exe", Properties.Resources.ClientExecutable);

avant de pouvoir appeler l'exécutable.

En ce qui concerne le lancement du processus en fenêtré, est-ce possible réellement?

N'ayant jamais eu ce besoin (définir la taille de l'écran) je ne sais pas. Je pense que c'est faisable (entre les API Windows et autre), mais je ne pourrais pas te répondre comme ça.

[cs_ntd]

Cependant y a t-il un moyen de gérer cela en mode graphique dans Visual C# ?

Que veux tu dire pas la ?


Sinon normalement, une fois que tu a récupéré le handle de la fenetre, tu peux tout faire dessus. Le probleme est parfois de prendre le bon handle. Certains processus en crées plusieurs, et celui par défault n'est pas forcemment celui de la fenetre.

Comment récupere tu ton handle, et comment l'utilise-tu ?

Code :

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

1
2
ProcessStartInfo* startInfo = new ProcessStartInfo(S"IExplore.exe");
    startInfo->WindowStyle = ProcessWindowStyle::Minimized;

C'est du C++ ca non ?

Il y a l'équivalent en C#, tu a essayé ?

[Feldunost]

Bonjour,


Excusez moi en ce qui concerne le retard, je suis actuellement en période d'examens donc ...


Donc, intégrer le client en tant que ressource, puis au clic du bouton, je mets ton WriteAllBytes ?

Code :

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

1
2
3
4
5
6
7
8
9
private void BT_Launcher_Click(object sender, EventArgs e)
{
System.IO.File.WriteAllBytes(@"C:\...\Client.exe", Properties.Resources.ClientExecutable);
System.Diagnostics.Process proc = new System.Diagnostics.Process();
proc.StartInfo.Filename = "Client.exe";
proc.StartInfo.Arguments = "/P192.168.1.145:7442";
proc.Start();
proc.Close();
}

En ce qui concerne le handle de la fenêtre: je ne connais que très peu ces fonctionnalités systèmes mais un tel handle dépend de l'OS si je me souviens bien.

J'ai un launcher qui a été fait par d'autres personnes (inutilisable désormais, mais qui fonctionnait auparavant), est ce possible de récupérer le handle dans leur launcher ?

Il me semble aussi par ailleurs qu'on peut obtenir le handle du processus, et d'interagir directement, beaucoup plus simple je pense.

Je ne sais pas clairement comment récupérer le handle du process mais le nom du processus visible dans le gestionnaire ne change pas : client.exe




Bref, les tutos sont utiles mais difficile de manier ces outils systèmes pointus ... merci pour l'intérêt porté toutefois !

[youtpout978]

pour windows style met à Normal déjà parce que à minimized la fenêtre sera réduite

pour récupérer ton handle utilise Findwindow http://pinvoke.net/default.aspx/user32.FindWindow

Le fonctionnement est simple

Code :

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

IntPtr handle=FindWindow("Client", null);

Ca devrait être ceci dans ton cas

[Feldunost]

Résumé:


Démarrer client dans ressources, sans paramètres de window handle:

Code :

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

1
2
3
4
5
6
7
8
9
private void BT_Launcher_Click(object sender, EventArgs e)
{
System.IO.File.WriteAllBytes(@"C:\...\Client.exe", Properties.Resources.ClientExecutable);
System.Diagnostics.Process proc = new System.Diagnostics.Process();
proc.StartInfo.Filename = "Client.exe";
proc.StartInfo.Arguments = "/P192.168.1.145:7442";
proc.Start();
proc.Close();
}

Démarrer client avec paramètres de handle: [sûrement incorrect]

Code :

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

1
2
using System.Runtime.InteropServices;
using System.Diagnostics;

Code :

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

1
2
3
4
5
6
7
8
9
10
11
private void BT_LauncherHandled_Click(object sender, EventArgs e)
{
System.IO.File.WriteAllBytes(@"C:\...\Client.exe", Properties.Resources.ClientExecutable);
System.Diagnostics.Process proc = new System.Diagnostics.Process();
proc.StartInfo.Filename = "Client.exe";
proc.StartInfo.Arguments = "/P192.168.1.145:7442";
IntPtr handle=FindWindow("Client", null);
SetWindowPos(HWND,IntPtr,0,0,800,600,SWP_NOMOVE);
proc.Start();
proc.Close();
}

Je me suis basé dessus :

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
using System.Runtime.InteropServices;
using System.Diagnostics;
 
private const uint SWP_NOMOVE = 2;
[DllImport("user32.dll")]
private static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int X, int Y, int cx, int cy, uint uFlags);
 
private void button1_Click(object sender, System.EventArgs e)
{
Process p = new Process();
p.StartInfo.FileName = "iexplore";
p.StartInfo.Arguments = "http://www.l-d.com";
if (p.Start())
{
IntPtr hWnd = p.MainWindowHandle;
SetWindowPos(hWnd,IntPtr.Zero,0,0,800,600,SWP_NOMOVE);
}
else
{
MessageBox.Show("impossible de lancer le process");
}
}

Je comptais faire 2 boutons pour 2 dimensions de fenêtres différentes.

Par contre le write all bytes signifie que lors de la compilation, les bytes du client seront copiés et utilisés en tant que ressource dans le launcher, il n'y a donc pas besoin d'ajouter l'exécutable (client.exe) dans les ressources manuellement puisque ce serait fait à la compilation ?

[StormimOn]

Par contre le write all bytes signifie que lors de la compilation, les bytes du client seront copiés et utilisés en tant que ressource dans le launcher, il n'y a donc pas besoin d'ajouter l'exécutable (client.exe) dans les ressources manuellement puisque ce serait fait à la compilation ?

Cela n'a absolument rien à avoir avec la compilation. La méthode File.WriteAllBytes va écrire le contenu d'un tableau d'octets dans un fichier, afin dans ton cas de recréer le client.exe, à partir du fichier en ressource, que tu pourras ensuite appeler. La ressource doit exister pour ça et doit donc être ajoutée manuellement.

[Feldunost]

Ok, merci pour l'éclaircissement.

Ce code est correct au niveau du IntPtr ?

Code :

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

1
2
IntPtr handle=FindWindow("Client", null);
SetWindowPos(HWND,IntPtr,0,0,800,600,SWP_NOMOVE);

Ou bien il fallait mettre:

Code :

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

1
2
IntPtr handle=FindWindow("Client", null);
SetWindowPos(HWND,handle,0,0,800,600,SWP_NOMOVE);

Le SWP_NOMOVE signifie que la fenêtre ne peut pas être déplacée si je comprends bien.

Donc si j'efface SWP_NOMOVE et laisse une valeur null, nous pourrions bouger cette fenêtre ?

[youtpout978]

Voilà un très bon site pour l'utilisation des api Windows http://pinvoke.net/default.aspx/core...WindowPos.html

Il y a même un très bon exemple:

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 void ShowStartBar()
    {
        IntPtr handle;
 
        try
        {
        // Find the handle to the Start Bar
        handle = FindWindowW("HHTaskBar", null);
 
        // If the handle is found then show the start bar
        if (handle != IntPtr.Zero)
        {
            // Show the start bar
            SetWindowPos(handle, 0, 0, 0, 240, 26, SWP_SHOWWINDOW);
        }
        }
        catch
        {
        MessageBox.Show("Could not show Start Bar.");
        }
    }

[Feldunost]

Cela n'a absolument rien à avoir avec la compilation. La méthode File.WriteAllBytes va écrire le contenu d'un tableau d'octets dans un fichier, afin dans ton cas de recréer le client.exe, à partir du fichier en ressource, que tu pourras ensuite appeler. La ressource doit exister pour ça et doit donc être ajoutée manuellement.

Ok, donc le Write all bytes doit être écrit en début de programme, pas dans l'espace du bouton si je me trompe pas?

Code :

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

1
2
using System.Runtime.InteropServices;
using System.Diagnostics;

Code :

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

System.IO.File.WriteAllBytes(@"C:\...\Client.exe", Properties.Resources.ClientExecutable);

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
private void BT_LauncherHandled_Click(object sender, EventArgs e)
{
        Properties.Resources.ClientExecutable); 
        System.Diagnostics.Process proc = new System.Diagnostics.Process();
        proc.StartInfo.Filename = "Client.exe";
        proc.StartInfo.Arguments = "/P192.168.1.145:7442";
 
        IntPtr handle;
 
        try
        {
        handle = FindWindowW("Client", null);
        if (handle != IntPtr.Zero)
        {
            SetWindowPos(handle, 0, 0, 0, 1280, 1024, SWP_SHOWWINDOW);
        }
        }
        catch
        {
        MessageBox.Show("Could not show Window.");
        }
    }

Là ça devrait être mieux, qu'en pensez vous ?