Come passare gli argomenti a un'applicazione di console se è già in esecuzione?

Question

Io uso un'applicazione console in Windows Mobile per gestire l'intercettazione del messaggio in entrata.Nella stessa applicazione console accetto i parametri (string args []) che in base ai parametri, registrare l'intercettore del messaggio.

InterceptPortype è un enum

static void Main(string[] args)
        {                 

            if (args[0] == "Location")
            {               

                addInterception(InterceptorType.Location, args[1],args[2]);
            } 

        }


private static void addInterception(InterceptorType type, string Location, string Number )
    {

        if (type == InterceptorType.Location)
        {

           using (MessageInterceptor interceptor = new MessageInterceptor(InterceptionAction.NotifyAndDelete, false))
           {

               interceptor.MessageCondition = new MessageCondition(MessageProperty.Sender, MessagePropertyComparisonType.Contains, Number, false);

               string myAppPath = Assembly.GetExecutingAssembly().GetName().CodeBase;

               interceptor.EnableApplicationLauncher("Location", myAppPath);

               interceptor.MessageReceived += new MessageInterceptorEventHandler(interceptor_MessageReceived);


           }


        }


    }


static void interceptor_MessageReceived(object sender, MessageInterceptorEventArgs e)
    {

        //Do something



    }

.

Ho reso questa applicazione di console perché voglio che continui a correre in background e intercetta i messaggi in arrivo.

funziona bene per la prima volta.Ma il problema è che devo continuare a chiamare il metodo addintercetto per aggiungere le norme di intercettazione successive.Ciò rende l'applicazione della console ricominciare e ancora per ogni volta che aggiungo una regola.Come faccio a fare questa corsa una sola volta e aggiungo più regole dell'intercettazione del messaggio?

Answer 1

Poiché hai già un metodo in posizione per chiamare il prompt dei comandi una volta, aggiornare la logica con un po 'di ciclo semplice in modo da poter passare n comandi.

Modifica: L'ho scritto un esempio completamente compilabile per mostrarti esattamente quello di cui sto parlando.Nota come il processo figlio può essere chiamato un numero qualsiasi di volte senza rilancio.Questo non è solo un semplice lancio della riga di comando con gli argomenti passati perché quell'idea porterà a X processi che è esattamente ciò che non vuoi.

Processo genitore: (quello con System.Diagnostics.Process)

/// <summary>
    /// This is the calling application.  The one where u currently have System.Diagnostics.Process
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            System.Diagnostics.Process p = new Process();
            p.StartInfo.CreateNoWindow = false;
            p.StartInfo.UseShellExecute = false;
            p.StartInfo.FileName = @"C:\AppfolderThing\ConsoleApplication1.exe";
            p.StartInfo.RedirectStandardError = true;
            p.StartInfo.RedirectStandardInput = true;
            p.StartInfo.RedirectStandardOutput = true;


            p.Start();            
            p.OutputDataReceived += delegate(object sender, DataReceivedEventArgs e)
            {
                Console.WriteLine("Output received from application: {0}", e.Data);
            };
            p.ErrorDataReceived += delegate(object sender, DataReceivedEventArgs e)
            {
                Console.WriteLine("Output received from application: {0}", e.Data);
            };
            p.BeginErrorReadLine();
            p.BeginOutputReadLine();
            StreamWriter inputStream = p.StandardInput;
            inputStream.WriteLine(1);
            inputStream.WriteLine(2);
            inputStream.WriteLine(-1);//tell it to exit
            p.WaitForExit();
        }

    }

.

Processo infantile:

    using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication3
{
    enum InterceptorType
    {
        foo,
        bar,
        zee,
        brah
    } 
    /// <summary>
    /// This is the child process called by System.Diagnostics.Process
    /// </summary>
    class Program
    {
        public static void Main()
        {
            while (true)
            {
                int command = int.Parse(Console.ReadLine());
                if (command == -1)
                    Environment.Exit(0);
                else
                    addInterception((InterceptorType)command, "some location", "0");
            }
        }
        private static void addInterception(InterceptorType type, string Location, string Number)
        {
            switch (type)
            {
                case InterceptorType.foo: Console.WriteLine("bind foo"); break;
                case InterceptorType.bar: Console.WriteLine("bind bar"); break;
                default: Console.WriteLine("default bind zee"); break;
            }

        }


        static void interceptor_MessageReceived(object sender, EventArgs e)
        {
            //Do something  
        }  
    }
}

.

Nota che Codeplex ha un Libreria di servizio gestita .

Answer 2

Modifica

Sembra che le persone siano mistintesanti la tua domanda (o io sono) quindi ecco alcuni chiarimenti su come sto vedendo il problema.

Hai un'app console che accetta i parametri della riga di comando. Questi parametri sono usati per qualcosa (il che cosa è irrilevante). Vuoi essere in grado di aggiungere parametri dopo che l'app è già in esecuzione chiamando l'app con la nuova riga di comando args.

Che cosa sta succedendo è che quando si chiama l'app in qualsiasi momento dopo che prima, una nuova istanza del processo si avvia anziché gli argomenti della riga di comando che vanno all'applicazione esistente, già in esecuzione.

End Modifica

La soluzione è abbastanza semplice e richiede due pezzi.

.

1. È necessario un denominato mutex. Per qualsiasi ragione (scarsa), il CF non esporrà una versione di un mutex che prende un nome, quindi devi P / invocateMutex o usa una libreria (come l'SDF) che lo ha già. La tua app deve creare il mutex all'avvio e controllare se esiste già. Se non sei la prima istanza in esecuzione ed esegui normalmente. Se il mutex esiste, è necessario passare la riga di comando args a quello che è già in esecuzione tramite A coda P2P , quindi semplicemente uscite.

2. Dopo aver controllato il mutex, la prima istanza genera un filo del lavoratore. Questo thread ascolta una coda P2P per i messaggi. Quando entrano, li gestisci.