arguments Pass à l'application en cours d'exécution

Question

Je fais une Uploader d'image (image de téléchargement à l'image site web d'hébergement) et je vais avoir des problèmes en passant un argument (emplacement de l'image à une application déjà en cours d'exécution)

• d'abord tous Disons que MyApp.exe est toujours en cours d'exécution
• Chaque fois que je fais un clic droit sur une image, j'ai ajouté un élément dans le menu contextuel de la fenêtre par défaut qui dit "Upload image".
• Lorsque cela est cliqué, il doit transmettre l'emplacement à l'application en cours d'exécution.

Mes Program.cs:

static class Program 
{ 
    [DllImport("user32.dll")] 
    static extern IntPtr FindWindow(string lpClassName, string lpWindowName); 

    [DllImport("user32.dll")] 
    static extern IntPtr SendMessage(IntPtr hWnd, uint Msg, UIntPtr 
    wParam, IntPtr lParam); 

    [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Auto)] 
    static extern uint RegisterWindowMessage(string lpString); 

    [STAThread] 
    static void Main(params string[] Arguments) 
    { 
     if (Arguments.Length > 0) 
     { 
    //This means that the the upload item in the context menu is clicked 
    //Here the method "uploadImage(string location)" 
    //of the running application must be ran 
     } 
     else 
     { 
    //just start the application 
      Application.Run(new ControlPanel()); 
     } 
    } 
} 

Notez que la classe ControlPanel ne dispose pas d'une forme visible, seule une icône de la barre est présente depuis une forme n'est pas nécessaire.

Pourrais-je obtenir de l'aide sur la façon de procéder?

Answer 1

Je l'ai compris, donc merci pour la personne qui a posté le lien http://social.msdn.microsoft.com/Forums/en-US/csharpgeneral/thread/a5bcfc8a-bf69-4bbc-923d-f30f9ecf5f64, c'est exactement ce que je cherchais!

Voici une solution complète:

static class Program 
{ 
    [STAThread] 
    static void Main(params string[] Arguments) 
    { 
     SingleInstanceApplication.Run(new ControlPanel(), NewInstanceHandler); 
    } 

    public static void NewInstanceHandler(object sender, StartupNextInstanceEventArgs e) 
    { 
     string imageLocation = e.CommandLine[1]; 
     MessageBox.Show(imageLocation); 
     e.BringToForeground = false; 
     ControlPanel.uploadImage(imageLocation); 
    } 

    public class SingleInstanceApplication : WindowsFormsApplicationBase 
    { 
     private SingleInstanceApplication() 
     { 
      base.IsSingleInstance = true; 
     } 

     public static void Run(Form f, StartupNextInstanceEventHandler startupHandler) 
     { 
      SingleInstanceApplication app = new SingleInstanceApplication(); 
      app.MainForm = f; 
      app.StartupNextInstance += startupHandler; 
      app.Run(Environment.GetCommandLineArgs()); 
     } 
    } 
} 

Merci beaucoup tout, et surtout la personne qui a posté ce lien je l'ai mentionné ci-dessus, mais je suppose qu'il supprimé sa réponse?

Cordialement, Kenny

Answer 2

En supposant que vous avez le contrôle sur l'environnement d'exécution, l'application d'écoute pourrait simplement exposer un point de terminaison en utilisant WCF ou même un socket TCP brut. De cette façon, toute autre application peut s'y connecter de manière dynamique mais structurée.

Même si l'expéditeur et le destinataire sont sur la même machine, l'utilisation d'une solution de transport réseau (comme WCF ou TCP) est un excellent moyen d'envoyer des données en toute sécurité à travers les processus.

Voici un exemple de la façon de le faire dans TCP avec C#: http://www.switchonthecode.com/tutorials/csharp-tutorial-simple-threaded-tcp-server

WCF peut être un peu plus compliqué (due en partie à sa flexibilité, et aussi en raison des restrictions de sérialisation) mais il y a beaucoup de documentation en ligne sur la façon de l'utiliser. WCF est une solution plus orientée objet parce que les classes de proxy peuvent être générées qui vous permettent de faire des appels fortement typés à des objets réels, par opposition à simplement envoyer des messages.

Answer 3

Eh bien, vous devrez établir un canal de communication pour d'autres applications à publier les images. Ce canal de communication peut être l'un des éléments suivants - pas une liste complète seulement des échantillons:

• Un répertoire qui est surveillé par votre application et le fichier est ajouté une fois qu'il est ajouté au répertoire.
• Port auquel d'autres applications peuvent envoyer des informations.
• Un service Web auto-hébergé qui accepte les images.
• Un port TCP qui reçoit les images.
• Un tuyau nommé.
• ....

Comme vous le voyez, il y a plusieurs possibilités. La bonne pour vous dépend de votre scénario. Le système de fichiers est une option qui peut être facilement implémentée en utilisant un FileSystemWatcher pour un échantillon see here.

Un service Web auto-hébergé expose un service Web pouvant recevoir des images. See here pour un échantillon.

À mon humble avis, ce sont les deux options qui sont les plus faciles. Mais ... il y en a plusieurs autres.

Pour le port TCP, voir la publication de Tim.

Answer 4

J'ai ajouté quelques petits ajouts à la solution précédente pour faire référence à un setter sur le formulaire afin de transmettre les arguments à lui.

Donc tout d'abord, créez une référence statique à l'instance initiale du formulaire (MainForm).

Ensuite, lors de l'envoi ultérieur d'arguments, NewInstanceHandler peut utiliser la référence sauvegardée au formulaire pour accéder à ses méthodes/propriétés publiques (dans mon cas, un setter appelé AddItem).

Un moyen facile de tester cela est d'ajouter une propriété publique à votre formulaire avec un setter pour modifier la propriété text du formulaire (le texte du titre).

[STAThread] 
    static Form1 MainForm; 

    static void Main(params string[] Arguments) 
    { 
     Application.EnableVisualStyles(); 
     Application.SetCompatibleTextRenderingDefault(false); 
     MainForm = new Form1(); 
     SingleInstanceApplication.Run(MainForm, NewInstanceHandler); 
    } 

    public static void NewInstanceHandler(object sender, StartupNextInstanceEventArgs e) 
    { 
     MainForm.AddItem = e.CommandLine[1]; 
     e.BringToForeground = false; 
    } 

    public class SingleInstanceApplication : WindowsFormsApplicationBase 
    { 
     private SingleInstanceApplication() 
     { 
      base.IsSingleInstance = true; 
     } 

     public static void Run(Form f, StartupNextInstanceEventHandler startupHandler) 
     { 
      SingleInstanceApplication app = new SingleInstanceApplication(); 
      app.MainForm = f; 
      app.StartupNextInstance += startupHandler; 
      app.Run(Environment.GetCommandLineArgs()); 
     } 
    } 

Answer 5

Pour éviter le fonctionnement de deuxième instance après avoir passé les arguments de ligne de commande instance existante, j'ai ajouté ci-dessous l'extrait de code.

static class Program 
{ 
    [STAThread] 

    static void Main(params string[] Arguments) 
    { 
     Form1 MainForm; 
     bool bInstanceFlag; 

     Mutex MyApplicationMutex = new Mutex(true, "MyApp_Mutex", out bInstanceFlag); 

     Application.EnableVisualStyles(); 
     Application.SetCompatibleTextRenderingDefault(false); 

     if (!bInstanceFlag) 
     { 
      MainForm = new Form1(); 
     SingleInstanceApplication.Run(MainForm, NewInstanceHandler); 
    } 
    else 
    { 
     MainForm = new Form1(); 
     SingleInstanceApplication.Run(MainForm, NewInstanceHandler); 
     MainForm.Close(); 
    } 
} 

public static void NewInstanceHandler(object sender, StartupNextInstanceEventArgs e) 
{ 
    MainForm.AddItem = e.CommandLine[1]; 
    e.BringToForeground = false; 
} 

public class SingleInstanceApplication : WindowsFormsApplicationBase 
{ 
    private SingleInstanceApplication() 
    { 
     base.IsSingleInstance = true; 
    } 

    public static void Run(Form f, StartupNextInstanceEventHandler startupHandler) 
    { 
     SingleInstanceApplication app = new SingleInstanceApplication(); 
     app.MainForm = f; 
     app.StartupNextInstance += startupHandler; 
     app.Run(Environment.GetCommandLineArgs()); 
    } 
} 
}