credo che intenda una cosa del genere :
c'è un processo aperto di nome xxx, quando lui lo chiude vorrebbe spostare un detto file (magari scritto dal exe) da un altra parte...
@file001
in questo caso dovresti aprire un secondo exe che fa da watchdog process, ovvero controlla periodicamente l'esistenza o meno di detto processo, quando non esiste più fai partire la routine per lo spostamento del file. Tradotto in un help dovresti guardare la classe system.diagnostics.process per monitorare i processi, e la System.IO.File per spostare il file.
eccoti un esempio di codice :
codice:
public class ProcessMonitor
{
public delegate void ProcessEventHandler(object sender, ProcessEventArgs e);
public List<Process> ProcessList { get; private set; }
Timer timer;
string processName;
ProcessEventHandler processEventHandler = null;
public int Interval { get { return timer.Interval; } set { timer.Interval = value; } }
public enum ProcessAction { Open, Close}
public ProcessMonitor(string ProcessName, int Interval = 1000, bool StartTimer = true)
{
this.processName = ProcessName;
ProcessList = new List<Process>();
timer = new Timer();
timer.Interval = Interval;
timer.Tick += new EventHandler(t_Tick);
if (StartTimer) Start();
}
public event ProcessEventHandler ProcessStateChanged
{
add { this.processEventHandler += value; }
remove { this.processEventHandler -= value; }
}
void t_Tick(object sender, EventArgs e)
{
var pl = Process.GetProcessesByName(this.processName);
List<Process> processClosedList = new List<Process>();
ProcessList.ForEach(process =>
{
if (!pl.Select(s => s.Id).Contains(process.Id))
{
processClosedList.Add(process);
};
});
pl.ToList().ForEach(p =>
{
if (!ProcessList.Select(s => s.Id).Contains(p.Id))
{
ProcessList.Add(p);
OnProcessStateChanged(p, ProcessAction.Open);
}
});
processClosedList.ForEach(process =>
{
ProcessList.Remove(process);
OnProcessStateChanged(process, ProcessAction.Close);
});
}
protected void OnProcessStateChanged(Process process, ProcessAction Action)
{
if (processEventHandler != null)
{
ProcessEventArgs e = new ProcessEventArgs()
{
Process = process,
Action = Action
};
processEventHandler(this, e);
}
}
public void Start()
{
this.timer.Start();
}
public void Stop()
{
this.timer.Stop();
}
public class ProcessEventArgs : EventArgs
{
public Process Process {get;set;}
public ProcessAction Action {get;set;}
}
}
e puoi usarlo creando una nuova istanza di "ProcessMonitor" passando nel costruttore il nome del processo che vuoi monitorare (senza .exe), l'intervallo di tempo nella quale fai il controllo, e un valore che indica se far partire il monitor subito o a mano quando meglio credi, infine aggiungi un handler a .ProcessStateChanged. Nel ProcessMonitor.ProcessEventArgs troverai due proprietà, una (ProcessMonitor.ProcessAction Action) indica se il processo è stato aperto o chiuso, l'altra (Process Process) il processo che lo riguarda.
ad esempio puoi usarla così :
codice:
public partial class Form1 : Form
{
ProcessMonitor monitor;
public Form1()
{
InitializeComponent();
monitor = new ProcessMonitor("notepad",1000,false);
monitor.ProcessStateChanged += new ProcessMonitor.ProcessEventHandler(monitor_ProcessStateChanged);
this.Load += new EventHandler(Form1_Load);
}
void Form1_Load(object sender, EventArgs e)
{
monitor.Start();
}
void monitor_ProcessStateChanged(object sender, ProcessMonitor.ProcessEventArgs e)
{
if (e.Action == ProcessMonitor.ProcessAction.Open)
{
//aperto un nuovo processo
}
else
{
//chiuso un processo
}
this.dataGridView1.DataSource = null;
this.dataGridView1.DataSource = monitor.ProcessList;
}
}
EDIT :
Dimenticavo... la traduzione del codice da c# a vb.net è abbastanza semplice e ti servirà per capire come fare senza avere la pappa pronta 
sarà un ottimo esercizio vedrai... diversamente prova con i traduttori online
Permessi di invio
Rispondi quotando