Existe alguma maneira de executar processos em segundo plano?

Question

Não há qualquer linha de comando ou método .NET que executa um processo em segundo plano esconder qualquer janela tenta abrir?

Já tentei:

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

Com nenhum sucesso até agora

Answer 1

Confira o Matlab Motor .

Há ainda um interessante artigo em CodeProject, se esta abordagem se adapta às suas necessidades .

Answer 2

Eu revi o meu código e parece quase idêntico ao seu:

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

Process process = Process.Start(psi);

A única diferença notável (excepto formatação e qual construtor escolhemos PSI) é o meu uso de UseShellExecute e RedirectStandardOutput como eu precisava para ler o resultado do processo de ran.

Eu encontrei o código acima consistentemente executa um processo oculto no XP e Vista. Descobri também, no entanto, e você pode estar enfrentando o mesmo, que um processo oculto pode lançar outro processo que por padrão não está oculto. Em outras palavras, se você começar escondido Processo A e Processo A, por sua vez, arranca Processo B, você não tem controle sobre a forma como o processo B será exibido. Janelas que você não tem nenhum controle sobre pode ser exibida.

Espero que isso ajude um pouco. Boa sorte.

Answer 3

Você já tentou usar o Microsoft DOS start comando com o / B switch?

Microsoft DOS comando de partida

Por exemplo,

START /B cmd.exe

Answer 4

Não há Eu não sei uma maneira .Net pura para alcançar este objectivo.

Então eu pensei sobre kernel do Job Objetos , mas não encontrou nenhuma opção semelhante no restrições de interface do usuário .

Assim, a próxima ( ainda não verificado ) idéia é criar de processo suspensa, criar um Windows ligar então, que irá monitorar CallWndProc e filtrar WM_SHOW mensagens. (Então, com certeza, retomar o processo, esperar em um segmento separado até que ele termina, remover o gancho)

Answer 5

Você pode querer tentar o BackgroundWorker Classe no .Net Framework se você não tiver já. É para a execução de processos de longa execução em um segmento separado para impedi-los de impedir o UI. Dê uma olhada.

Answer 6

Sei que isso foi respondida, mas você pode forçar uma janela para esconder com chamadas não gerenciado para 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

Em vez kludgy.

Answer 7

Depende se você quer começar a aplicação minimizada, mas permitir que ele interaja com o usuário, se necessário, ou se você quer proibir todo o acesso com o usuário, independentemente do que acontece.

Neste último caso, você pode executar o processo em um contexto de trabalho diferente para o usuário atual.

Diferentes contextos de desktop são usados, por exemplo, pela caixa de diálogo de login e pelo Vista UAC -. Tudo o que acontece em um contexto de desktop é independente dos outros

Pode ser uma abordagem marreta para o seu problema embora.

Answer 8

Percebi que se CreateNoWindow = false não faz absolutamente nada quando o nome do arquivo é apontando para um executável do Windows, se você tiver acesso ao código-fonte do aplicativo winform então você pode ser capaz de fornecer um argumento de linha de comando que controla o padrão visibilidade do formulário, e fazer algo como isso no código do Winform App arranque:

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);
    }

Em que você chamar código, agora você pode especificar "dontShowWindow" como um argumento de processo:

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

Espero que isso ajude

Answer 9

Uma maneira muito simples de conseguir isso é para criar uma conta de serviço e executar o arquivo executável sob o contexto do usuário Conta de Serviço através do Agendador de Tarefas do Windows.

Você pode usar esta CodeProject para configurar a tarefa agendada:

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

Você pode criar a conta do serviço de programação na máquina de domínio ou local muito facilmente com C #.

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

processos em execução como tarefas agendadas no contexto de outro usuário não aparecem de forma interativa, a menos que o usuário está logado; daí o uso de uma conta de serviço.

Answer 10

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

Funciona muito bem!

Answer 11

Eu suponho que você quer um processo que não é visível para os usuários durante a execução.

Você pode tentar o seguinte para ver se isso é o que você quer.

1. Criar um aplicativo de console simples que mantém em execução (e lançá-lo para teste).
2. Botão direito do mouse sobre o Projeto -> Propriedades -> guia Aplicativo -> Tipo de Saída -.> Alterar-lo de "Console Application" para Windows Application
3. Inicie o mesmo aplicativo mais uma vez (para ver se isso é o que você quiser).
4. Feche o aplicativo por meio do Gerenciador de Tarefas do Windows:)

Parece que o processo aparece no Gerenciador de tarefas, no entanto, não é visível na barra de tarefas. Alt + TAB não pode trazer este processo.

Eu só espero que você não está fazendo nenhum aplicativo malicioso, embora:)

Answer 12

Eu acho que você pode querer tentar é criar uma nova Station do Windows. Confira este artigo que explica um pouco sobre eles no MSDN.

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

Answer 13

Você poderia fazer um serviço do Windows'. Qualquer janela um serviço tenta abrir apenas executa em sessão 0, o que significa que nenhum usuário pode vê-lo. Isso vale para todas as janelas, porém, por isso, talvez isso não é o que você está procurando.

Answer 14

Abaixo código funcionou para mim: No início do processo (bloco de notas) usado para piscar o bloco de notas na tela do desktop para a impressão, mas distrair o usuário, assim abaixo peles de código do processo de bloco de notas no fundo.

                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();
                }