[c#] Comunicare tra 2 progetti

[race2]

Salve,
ho 2 progetti, uno Win Form "A" e uno Console "B"

il progetto "A" contiene una classe Pubblica "MyClass"
il progetto "B" deve fare una ricerca in una data Directory,

1) A avvia B tramite "Process.Start(B.exe)"
2) B cerca sulla directory "Backup" e comunica subito alla classe "MyClass" in B
3) A esegue delle operazioni a seconda del risultato di B

la domanda:
una volta che "A" avvia "B", poi "B" in che modo comunica alla classe "MyClass" su "A" ???

- io ho provato a importare "A.exe" come Riferimento in "B",
- la vedo ma posso solo fare una nuova istanza e poi usarla,
- ma non comunicare all'istanza creara in "A".

[tomminno]

Molto stupidamente puoi parserizzare da A lo standard output restituito da B.

Altrimenti si va su tecniche un po' più "complesse" di comunicazione IPC tipo:
MemoryMappedFile (se usi .Net 4.0)
Socket
NamedPipe

[race2]

Avevo già pensato ad un socket in ascolto su "A" dove "B" ci spara il suo risultato,
solo che "A" mi sta in ascolto per tutto il giorno buttando giù il processore, sbaglio ?

"A" deve avviare molti processi Asincroni e aspettare le loro risposte, ci sono più PC da monitorare e ogniuno ha la sua lentezza.

Ho provato con i Thread, ma mi sono incasinato fino a prendere un esaurimento, questo non significa ceh se avete una soluzione con i Thread non la utilizzi...

[lorenzo001]

Che senso ha scrivere due progetti ?

Utilizza lo stesso progetto e inserisci tutto il codice che serve ...

[race2]

Originariamente inviato da lorenzo001

Che senso ha scrivere due progetti ?

Utilizza lo stesso progetto e inserisci tutto il codice che serve ...

"A" deve avviare molti processi Asincroni e aspettare le loro risposte, ci sono più PC da monitorare e ogniuno ha la sua lentezza.

voglio lanciare contemporaneamente 10 processi e non aspettare che ha finito il promo e passare al prossimo.

[Mettiu_]

Originariamente inviato da race2

"A" deve avviare molti processi Asincroni e aspettare le loro risposte, ci sono più PC da monitorare e ogniuno ha la sua lentezza.

voglio lanciare contemporaneamente 10 processi e non aspettare che ha finito il promo e passare al prossimo.

Usa i threads: semplifichi di molto la comunicazione interna visto che tutti quanti condividono lo stesso spazio di indirizzamento. Occhio solo alla sincronizzazione e alle sezioni critiche, se e quando ti serviranno!

[race2]

Avevo fatto questo in precedenza, ma mi è sfuggita di mano la gestione dei Thread.

        private void Start()
        {
            Computer oComputer;
            int iLoop = 0;
            int iMaxLoop = 10;

            //Elenco PC - ( ..potrebbero variare di numero... )
            ArrayList aComputerList = new ArrayList();

            aComputerList.Add(new Computer("192.168.1.5", "D:\\Backup\\Backup_2012_04_12\\", "myFile.txt"));
            aComputerList.Add(new Computer("192.168.1.10", "D:\\Backup\\Backup_2012_04_12\\", "myFile.txt"));
            aComputerList.Add(new Computer("192.168.1.15", "D:\\Backup\\Backup_2012_04_12\\", "myFile.txt"));
            aComputerList.Add(new Computer("192.168.1.20", "D:\\Backup\\Backup_2012_04_12\\", "myFile.txt"));
            aComputerList.Add(new Computer("192.168.1.25", "D:\\Backup\\Backup_2012_04_12\\", "myFile.txt"));

            //Creoo un Loop che non termina mai fino al raggiungimento di "iMaxLoop".
            for (int i = 0; i < aComputerList.Count; i++)
            {
                //Esco dal Loop
                if (iLoop >= iMaxLoop)
                {
                    MessageBox.Show("Fine Loop!");
                    return;
                }

                //Assegno l'istanza da utilizzare nel Loop corrente
                oComputer = (Computer)aComputerList[i];

                //Di Default lo Stato è "Libero", cioè questa istanza non è impegnata con la Ricerca
                if (oComputer.Status == false)
                {
                    oComputer.Status = true; //Imposto lo stato di ricerca a "Occupato", cioè stà cercando

                    t = new Thread(new ParameterizedThreadStart(Cerca));
                    t.Start(oComputer);
                }

                //Se i Computer sono finiti, riparto dal primo
                if (i == (aComputerList.Count - 1))
                {
                    i = -1;
                }
            }
        }



        public void Cerca(object _oComputer)
        {
            if (_oComputer != null)
            {
                //Ricerca------
                // --- code ---

                //Appena ho il risultato cercato lo passo al metodo "Result"
                ((Computer)_oComputer).Result = "il-mio-risultato";

                Thread.Sleep(60000);

                //Imposto lo stato di ricerca a "Libero", cosi 
                ((Computer)_oComputer).Status = false;
            }
        }

La dinamica dovrebbe essere la seguente:

1) parte il Loop dei Computer e quindi si avviano contemporaneamente 5 ricerche.
"ogni Computer ha più o meno file da scansionare, quindi i tempi sono diversi"

2) appena un processo tra i 5 avviati finisce, deve passare il risultato a "Start()" e non deve ripartire prima 1ora.

Questi due passaggi si ripetono per 8 volte.

[race2]

scusate ma nel riscrivere il codice avevo fatto degli errori, questo è quello funzionante ciciamo....

Come faccio per passare da "Cerca()" a "Start()" il risultato trovato dalla ricerca "il-mio-risultato" ???

        private void Start()
        {
            Computer oComputer;
            int iLoop = 0;
            int iMaxLoop = 10;

            //Elenco PC - ( ..potrebbero variare di numero... )
            ArrayList aComputerList = new ArrayList();

            aComputerList.Add(new Computer("192.168.1.5", "D:\\Backup\\Backup_2012_04_12\\", "myFile.txt"));
            aComputerList.Add(new Computer("192.168.1.10", "D:\\Backup\\Backup_2012_04_12\\", "myFile.txt"));
            aComputerList.Add(new Computer("192.168.1.15", "D:\\Backup\\Backup_2012_04_12\\", "myFile.txt"));
            aComputerList.Add(new Computer("192.168.1.20", "D:\\Backup\\Backup_2012_04_12\\", "myFile.txt"));
            aComputerList.Add(new Computer("192.168.1.25", "D:\\Backup\\Backup_2012_04_12\\", "myFile.txt"));

            //Creoo un Loop che non termina mai fino al raggiungimento di "iMaxLoop".
            for (int i = 0; i < aComputerList.Count; i++)
            {
                //Esco dal Loop
                if (iLoop >= iMaxLoop)
                {
                    MessageBox.Show("Fine Loop!");
                    return;
                }

                //Assegno l'istanza da utilizzare nel Loop corrente
                oComputer = (Computer)aComputerList[i];

                //Di Default lo Stato è "Libero", cioè questa istanza non è impegnata con la Ricerca
                if (oComputer.Status == false)
                {
                    oComputer.Status = true; //Imposto lo stato di ricerca a "Occupato", cioè stà cercando

                    t = new Thread(new ParameterizedThreadStart(Cerca));
                    t.Start(oComputer);

                    //Incremento la lettura delle ore
                    iLoop++;
                }

                //Se i Computer sono finiti, riparto dal primo
                if (i == (aComputerList.Count - 1))
                {
                    i = -1;
                }
            }
        }


        public void Cerca(object _oComputer)
        {
            if (_oComputer != null)
            {
                //Ricerca------
                // --- code ---

                //Appena ho il risultato cercato lo passo al metodo "Result"
                ((Computer)_oComputer).Result = "il-mio-risultato";

                Thread.Sleep(3000);

                //Imposto lo stato di ricerca a "Libero"
                ((Computer)_oComputer).Status = false;
            }
        }

[race2]

Ho fatto un passo in più,
ho inserito una Delegata per passare indietro lo stato dell'Istanza, posto il nuovo codice:

        public void Start()
        {
            Computer oComputer;
            Thread t;
            int iLoop = 0;
            int iMaxLoop = 10;

            //Elenco PC - ( ..potrebbero variare di numero... )
            ArrayList aComputerList = new ArrayList();

            aComputerList.Add(new Computer("192.168.1.5", "D:\\Backup\\Backup_2012_04_12\\", "myFile.txt"));
            aComputerList.Add(new Computer("192.168.1.10", "D:\\Backup\\Backup_2012_04_12\\", "myFile.txt"));
            aComputerList.Add(new Computer("192.168.1.15", "D:\\Backup\\Backup_2012_04_12\\", "myFile.txt"));
            aComputerList.Add(new Computer("192.168.1.20", "D:\\Backup\\Backup_2012_04_12\\", "myFile.txt"));
            aComputerList.Add(new Computer("192.168.1.25", "D:\\Backup\\Backup_2012_04_12\\", "myFile.txt"));

            //Creoo un Loop che non termina mai fino al raggiungimento di "iMaxLoop".
            for (int i = 0; i < aComputerList.Count; i++)
            {
                //Esco dal Loop
                if (iLoop >= iMaxLoop)
                {
                    MessageBox.Show("Fine Loop!");
                    return;
                }

                //Assegno l'istanza da utilizzare nel Loop corrente
                oComputer = (Computer)aComputerList[i];

                //Di Default lo Stato è "Libero", cioè questa istanza non è impegnata con la Ricerca
                if (oComputer.Status == false)
                {
                    //Imposto lo stato di ricerca a "Occupato", cioè stà cercando
                    oComputer.Status = true;

                    //Delegata
                    ThreadStart ts = delegate() { Cerca(oComputer); };

                    //Invio SMS al Provider tramite un nuovo Thread
                    t = new Thread(ts);
                    t.Start();

                    //Incremento il Loop
                    iLoop++;
                }

                //Se i Computer sono finiti, riparto dal primo
                if (i == (aComputerList.Count - 1))
                {
                    i = -1;
                }
            }
        }


        public void Cerca(Computer _oComputer)
        {
            if (_oComputer != null)
            {
                //Ricerca------
                //
                //

                //passo il risultato
                _oComputer.Result = "il-mio-risultato";

                //Apro un form
                Form f = new Form();
                f.Text = _oComputer.Ip; //Scrivo come Text del Form l'IP
                f.Show();

                Thread.Sleep(3000);

                //Imposto lo stato di ricerca a "Libero"
                _oComputer.Status = false;
            }
        }

funziona tutto,

solo che non prende le Istanze in maniera ordinata come quando le assegno,

su "Cerca()" a "f.Text = _oComputer.Ip;" l'IP spesso escono duplicati anche nel primo Loop da 0 a 5,

il che non dovrebbe essere dato che assegno l'istanza direttamente dentro il Loop: oComputer = (Computer)aComputerList[i];