C'è un modo per eseguire i processi in background?

Question

Esiste una riga di comando o un metodo .NET che esegue un processo in background nascondendo qualsiasi finestra che tenta di aprire?

Già provato:

 var process = new Process()
 {
      StartInfo = new ProcessStartInfo()
      {
          CreateNoWindow = true,
          WindowStyle = ProcessWindowStyle.Hidden,
          FileName = TheRealExecutableFileNameHere
      }
 }
 process.Start();

Senza successo finora

Answer 1

Controlla la Matlab motore .

C'è anche un interessante su CodeProject, se questo approccio si adatta alle vostre esigenze .

Answer 2

ho rivisto il mio codice e sembra quasi identico al vostro:

ProcessStartInfo psi = new ProcessStartInfo(fileName, arguments)
{
   CreateNoWindow = true,
   WindowStyle = ProcessWindowStyle.Hidden,
   UseShellExecute = false,
   RedirectStandardOutput = true                                               
};

Process process = Process.Start(psi);

L'unica differenza degna di nota (diversa formattazione e che il costruttore abbiamo scelto PSI) è il mio uso di UseShellExecute e RedirectStandardOutput come ho bisogno di leggere il risultato del processo di corse.

Ho trovato il codice di cui sopra costantemente esegue un processo nascosto su XP e Vista. Ho anche trovato, tuttavia, e potrebbe trattarsi dello stesso, che un processo nascosto può dare il via un altro processo che di default non è nascosta. In altre parole, se si avvia processo nascosto A e processo A, a sua volta, prende il via Processo B, si ha alcun controllo su come verrà visualizzato Processo B. possono essere visualizzate finestre che si ha alcun controllo.

Spero che questo aiuta un po '. Buona fortuna.

Answer 3

Hai provato utilizzando il Microsoft DOS inizio di comando con il / B switch?

Microsoft DOS avvia Command

Ad esempio,

START /B cmd.exe

Answer 4

Non c'è Non conosco un modo .Net puro per raggiungere questo obiettivo.

Poi ho pensato al kernel Oggetti lavoro, ma non ho trovato alcuna opzione simile in Restrizioni dell'interfaccia utente.

Quindi, il prossimo (ancora non verificato) l'idea è quella di creare un processo sospeso, creare un hook di Windows poi, che monitorerà CallWndProc e filtrare i messaggi WM_SHOW.(Quindi, sicuramente, riprendi il processo, attendi in un thread separato finché non termina, rimuovi il gancio)

Answer 5

Si consiglia di provare il BackgroundWorker Classe nel .NET Framework, se non l'hai già. È per eseguire processi lungo in esecuzione su un thread separato per impedire loro di ostacolare l'interfaccia utente. Dategli un'occhiata.

Answer 6

Mi rendo conto che questo è stato risposto, ma si potrebbe forzare una finestra per nascondere con le chiamate non gestite a FindWindow e ShowWindow.

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

[DllImport("user32.dll")]
static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);

psi = new ProcessStartInfo(); // etc..
some_process = Process.Start(psi);
System.Threading.Thread.Sleep(50); // need give the window a chance to be created
IntPtr hWnd = FindWindow(null, "name of the window");
if (hWnd != IntPtr.Zero) ShowWindow(hWnd, 0); // 0 = SW_HIDE

Piuttosto kludgy.

Answer 7

Dipende se si desidera avviare l'applicazione ridotta al minimo, ma permettono di interagire con l'utente, se richiesto, o se si vuole proibire tutti gli accessi con l'utente, indipendentemente da ciò che accade.

In quest'ultimo caso, è possibile eseguire il processo in un contesto diverso desktop per l'utente corrente.

Diversi contesti desktop vengono utilizzati, ad esempio, dalla finestra di dialogo di accesso e da Vista UAC -. Tutto ciò che accade in un contesto desktop è indipendente dagli altri

Potrebbe essere un approccio mazza per il vostro problema però.

Answer 8

Ho notato che se CreateNoWindow = false non fa assolutamente nulla quando il nome del file è punta a un file eseguibile di Windows, se si ha accesso al codice sorgente dell'app winform allora si potrebbe essere in grado di fornire un argomento da riga di comando che controlla il default la visibilità della forma, e fare qualcosa di simile nel codice di avvio Winform App:

static void Main(string[] args)
    {
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        Form1 form1 = new Form1();

        form1.Load += new EventHandler((s,o) =>
            {
              //check if the form should be shown based on command line arg
                if (args.Contains("dontShowWindow"))
                {
                    //hide it
                    form1.ShowInTaskbar = false;
                    form1.Visible = form1.ShowInTaskbar = false;
                }
            }
        );
        Application.Run(form1);
    }

In ti chiama codice, è ora possibile specificare "dontShowWindow" come argomento processo:

 ProcessStartInfo info = new ProcessStartInfo
        {
            CreateNoWindow = false, 
            WindowStyle = ProcessWindowStyle.Hidden,
            UseShellExecute = false, 
            FileName = @"C:\temp\testWinForm.exe",
            Arguments = "dontShowWindow"
        };
        Process.Start(info);

Spero che questo aiuti

Answer 9

Un modo molto semplice modo per raggiungere questo obiettivo è quello di creare un account di servizio ed eseguire il file eseguibile sotto il contesto dell'utente Account servizio tramite la pianificazione di Windows.

È possibile utilizzare questo CodeProject per impostare l'operazione pianificata:

http://www.codeproject.com/KB/cs/tsnewlib.aspx

È possibile creare l'account del servizio programatically nella macchina di dominio o locale molto facilmente con C #.

http://www.codeproject.com/KB/system/OSUserMangement.aspx http://support.microsoft.com/kb/306273

I processi in esecuzione come operazioni pianificate nel contesto di un altro utente non vengono visualizzati in modo interattivo a meno che l'utente è connesso; quindi l'uso di un account di servizio.

Answer 10

public Form1()
    {
        InitializeComponent();
        Form1 fm = new Form1();
        fm.ShowInTaskbar = false;
        fm.Visible = fm.ShowInTaskbar = false;
    }

funziona benissimo!

Answer 11

Presumo che si desidera un processo che non è visibile agli utenti durante la corsa.

È possibile provare la seguente per vedere se questo è ciò che si desidera.

1. Creare una semplice applicazione console che continua a funzionare (e lanciarlo alla prova).
2. Fare clic destro sul Progetto -> Proprietà -> scheda Applicazioni -> Tipo di uscita -> cambiare da "Applicazione Console" a Windows Application
.
3. Avviare la stessa applicazione ancora una volta (per vedere se questo è ciò che si desidera).
4. Chiudere l'applicazione tramite Task Manager di Windows:)

Sembra che il processo sembra in Task Manager, tuttavia, non è visibile nella barra delle applicazioni. ALT + TAB non possono portare questo processo in su.

Mi auguro solo che non stanno facendo qualsiasi applicazione maligni, però:)

Answer 12

Credo che ciò che si potrebbe desiderare di provare è quello di creare una nuova stazione di Windows. Dai un'occhiata a questo articolo che spiega un po 'su di loro su MSDN.

http://msdn.microsoft.com /en-us/library/ms681928(VS.85).aspx

Answer 13

Si potrebbe rendere il servizio Windows'. Qualsiasi finestra di un servizio tenta di aprire appena viene eseguito in sessione 0, il che significa che nessun utente può vederlo. Questo vale anche per tutte le finestre, però, quindi forse questo non è quello che stai cercando.

Answer 14

Di seguito il codice ha funzionato per me: In precedenza il processo (notepad) utilizzato per flashare il blocco note sul desktop per la stampa, ma distrarre l'utente, quindi al di sotto del codice nasconde il processo di blocco note in background.

                System.Windows.Forms.PrintDialog printDialog = new PrintDialog();
                System.Diagnostics.ProcessStartInfo psi = new System.Diagnostics.ProcessStartInfo(Application.StartupPath + "/PrintingDocketFile/PrintCustomerOrder.txt");
                psi.Verb = "PRINT";

                //Process.Start(psi);
                //psi.CreateNoWindow = true;
                psi.UseShellExecute = false;
                //---------------------------------------------------

                psi.CreateNoWindow = false;
                psi.UseShellExecute = true;
                psi.FileName = Application.StartupPath + "/PrintingDocketFile/PrintCustomerOrder.txt";
                psi.WindowStyle = ProcessWindowStyle.Hidden;
                psi.Arguments =  @"%windir%\system32\notepad.exe"; 
                //Process.Start(psi);
                //------------------------------------------------------

                /////////////////////----------------------------------

                printProcess.StartInfo = psi;
                /////psi.CreateNoWindow = true;

                //psi.FileName = "Application.StartupPath" + "/PrintingDocketFile/PrintCustomerOrder.txt";
                //p.StartInfo.FileName = "Notepad.EXE";
                //p.StartInfo.Arguments = "/i /q \"" + installationPackages[i] + "\"";

                printProcess.Start();

                /////////////////////////-------------------------------
                while (!printProcess.HasExited) ;


                if (!printProcess.HasExited)
                {
                    printProcess.Close();
                }