Problema Antecedentes

Eu criei um processo de publicação "Um clique" para meus arquivos de projeto Flash (* .fla) com um programa C # que executa as seguintes operações:

Atualiza uma variável "versão" estática em dois arquivos principais de projeto (um para cada projeto FLA)Altera um arquivo de modelo JSFL incorporado (automatiza a abertura / publicação de um arquivo FLA específico) e grava-o no disco para ser usado na próxima etapaChama o Flash Professional via Process.Start, passando o caminho para o flash.exe e o nome do arquivo JSFL como argumento, para que o flash execute o arquivo JSFL e publique o projetoPublica arquivos de projeto no meu servidor Web (backup / cópia de arquivo simples via unidade compartilhada mapeada no túnel VPN Win7 <-> WinServer2012)

A interface do usuário possui três botões, um para publicar o primeiro projeto, um para publicar o segundo projeto e um para publicar os dois projetos. O segundo projeto depende do primeiro, portanto, se e quando o botão "publicar os dois" for clicado, ele deverá concluir completamente a publicação do primeiro arquivo antes de publicar o segundo.

Para cada projeto, ele lê o arquivo principal da classe de documento AS na memória como uma sequência e usa um Regex para atualizar variáveis estáticas "versão" específicas para ter um registro de data e hora atual. Em seguida, ele reescreve os arquivos com a versão atualizada. O objetivo da variável "version" é ser exibido em tempo de execução no navegador, por isso estou certo de que estou testando a versão compilada mais recentemente do projeto.

O Flash Professional aceita um nome de arquivo JSFL como argumento da linha de comando, mas não permite que outros argumentos sejam transmitidos para esse arquivo JSFL; portanto, o programa altera um modelo JSFL para incluir os parâmetros adequados e passa o arquivo JSFL temporário personalizado para o Flash Professional via Process.Start.

A publicação na Web ocorre por meio de outros recursos genéricos que me permitem especificar uma lista de caminhos de origem e destino (com backup com carimbo de data e hora opcional de cada arquivo), que automatiza o backup e a cópia de arquivos publicados específicos no meu servidor da Web.

Problema

Antes de tudo, devo mencionar que tudo funciona bem quando estou publicando apenas um arquivo de projeto, e o problema que estou tentando resolver é o de sincronização ou sinalização de eventos.

O Flash é um aplicativo somente de instância única; portanto, a execução de Process.Start iniciará o Flash Professional se ele ainda não estiver em execução e executará o script JSFL, ou o script JSFL na instância existente do Flash Professional.

O primeiro problema é depois de chamar Process.Start, não posso chamar waitForExit para a tarefa ser concluída, porque o Flash permanece aberto. Se o Flash já estiver aberto, o waitForExit retornará rapidamente, porque a segunda instância do Flash.exe será fechada após o encaminhamento do comando para a instância principal. Aplicativos apenas de instância única não impedem que um segundo processo seja iniciado, eles matam rapidamente o segundo processo quando ele detecta que um já está em execução e encaminha o comando para ele. Por esse motivo, não posso simplesmente esperar que o processo saia, pois o Flash pode ou não estar aberto.

Supondo que não espere nada, meu aplicativo chamará Process.Start rapidamente duas vezes, uma vez para cada projeto, passando um nome de arquivo JSFL exclusivo para executar em cada um. O problema é que a primeira chamada parece ser descartada. Não tenho certeza se esse comportamento está enraizado no sistema operacional Windows ou no aplicativo Flash Professional. Isso ocorre quando o Flash ainda não está aberto. A chamada inicial Process.Start e os parâmetros correspondentes devem ser o que ativa o Flash, então eu esperava que isso acontecesse, no entanto, como o Flash está inicializando, quando finalmente mostra a janela principal, é apenas o segundo script que é executado.

De maneira interessante, se o Flash já tiver sido iniciado, os dois scripts parecerão executados, apesar de sua rápida ativação (vejo os dois documentos abertos no IDE), mas a publicação simultânea realmente causa o travamento do Flash (a janela principal desaparece e o processo termina abruptamente sem nenhum erro )

Então, eu preciso de uma maneira de coordenar a emissão desses comandos Process.Start. Felizmente, o método "publicar" JSFL é síncrono e o JSFL é capaz de executar comandos de linha de comando; talvez, assim que o método de publicação retorne, eu possa chamar um EXE externo para funcionar como um mecanismo de coordenação para detectar quando cada script concluiu seu trabalho antes. executando o próximo? Alguém tem alguma experiência com esse tipo de comunicação entre processos que poderia me ajudar?

TL; DR

Preciso saber como criar um executável simples, que, quando chamado da linha de comando, ele envia uma mensagem para um processo externo específico, indicando que uma operação foi concluída. Basicamente, um script JSFL em execução no Flash Professional deve chamar o exe por meio do"não documentado" FLfile.runCommandLine depois que o arquivo terminar de publicar, e esse exe deverá notificar meu programa de automação para que ele saiba que o Flash terminou de publicar o arquivo e está pronto para executar outro script JSFL para publicar o próximo arquivo.