You can use P/Invoke to access the Win32 CreateEvent API to create named
events. I created this test app fairly quicklly that seems to work...
in project 1
using System;
using System.Diagnost ics;
using System.Threadin g;
using System.Runtime. InteropServices ;
namespace ConsoleApplicat ion1
{
/// <summary>
/// Summary description for Class1.
/// </summary>
class Class1
{
[DllImport("kern el32.dll", SetLastError=tr ue)]
static extern IntPtr CreateEvent(Int Ptr lpEventAttribut es, bool
bManualReset,
bool bInitialState, string lpName);
[DllImport("kern el32.dll")]
static extern bool SetEvent(IntPtr hEvent);
[DllImport("kern el32.dll")]
static extern bool ResetEvent(IntP tr hEvent);
[DllImport("kern el32.dll", SetLastError=tr ue)]
static extern int CloseHandle(Int Ptr hObject);
const int ERROR_ALREADY_E XISTS = 183;
/// <summary>
///
/// </summary>
[STAThread]
static void Main(string[] args)
{
string file =
@"..\..\..\Cons oleApplication2 \bin\debug\Cons oleApplication2 .exe";
if ( !System.IO.File .Exists(file) )
{
Print("Unable to locate file {0}",file);
return;
}
Process p = new Process();
ProcessStartInf o psi = new ProcessStartInf o(file,"2");
p.StartInfo = psi;
IntPtr handle;
bool createdNew;
if ( !CreateManagedE vent(out handle,out createdNew) )
{
Print("Error creating named event.");
return;
}
if ( !createdNew )
{
Print("App2 already running. Press any key to exit...");
Console.ReadLin e();
return;
}
else
{
Console.WriteLi ne("Starting other app");
ManualResetEven t _evt = new ManualResetEven t(false);
_evt.Handle = handle;
_evt.Reset();
DateTime start = DateTime.Now;
p.Start();
Print("Waiting. ...");
_evt.WaitOne(Ti meSpan.FromSeco nds(15),false);
TimeSpan elapsed = DateTime.Now - start;
Print("Done waiting; it took {0} seconds...",ela psed.Seconds);
}
Print("All done");
}
/// <summary>
/// Creates a named event in the win32 space. This is a manual
/// reset event that is initially not signalled.
/// </summary>
/// <param name="handle"></param>
/// <param name="createdNe w">true if it created a new one, false if it
opened an existing one</param>
/// <returns>true if it succeeds, otherwise false</returns>
static bool CreateManagedEv ent(out IntPtr handle,out bool createdNew)
{
createdNew = false;
handle = CreateEvent(Int Ptr.Zero, true,false, "MyNamedEvent") ;
int error = Marshal.GetLast Win32Error();
if ( handle == IntPtr.Zero )
return false;
createdNew = (error != ERROR_ALREADY_E XISTS);
return true;
}
static void Print(string format,params object[] args)
{
string msg = string.Format(f ormat,args);
Trace.WriteLine (msg);
Console.WriteLi ne(msg);
}
}
}
in project 2
using System;
using System.Diagnost ics;
using System.Threadin g;
using System.Runtime. InteropServices ;
namespace ConsoleApplicat ion2
{
/// <summary>
/// Summary description for Class1.
/// </summary>
class Class2
{
[DllImport("kern el32.dll", SetLastError=tr ue)]
static extern IntPtr CreateEvent(Int Ptr lpEventAttribut es, bool
bManualReset,
bool bInitialState, string lpName);
[DllImport("kern el32.dll")]
static extern bool SetEvent(IntPtr hEvent);
[DllImport("kern el32.dll")]
static extern bool ResetEvent(IntP tr hEvent);
[DllImport("kern el32.dll", SetLastError=tr ue)]
static extern int CloseHandle(Int Ptr hObject);
const int ERROR_ALREADY_E XISTS = 183;
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main(string[] args)
{
IntPtr handle;
bool createdNew;
if ( !CreateManagedE vent(out handle,out createdNew) )
{
Print("Error creating named event.");
return;
}
if ( createdNew )
{
Print("App1 not running yet, exiting after a 10 second wait...");
Thread.Sleep( TimeSpan.FromSe conds(10) );
return;
}
Print("Sleeping for a few seconds...");
Thread.Sleep( TimeSpan.FromSe conds(2) );
Print("Done sleeping, setting event...");
ManualResetEven t _evt = new ManualResetEven t(false);
_evt.Handle = handle;
_evt.Set();
Print("Sleeping for 10 more seconds...");
Thread.Sleep( TimeSpan.FromSe conds(10) );
Print("Done");
}
/// <summary>
/// Creates a named event in the win32 space. This is a manual
/// reset event that is initially not signalled.
/// </summary>
/// <param name="handle"></param>
/// <param name="createdNe w">true if it created a new one, false if it
opened an existing one</param>
/// <returns>true if it succeeds, otherwise false</returns>
static bool CreateManagedEv ent(out IntPtr handle,out bool createdNew)
{
createdNew = false;
handle = CreateEvent(Int Ptr.Zero, true,false, "MyNamedEvent") ;
int error = Marshal.GetLast Win32Error();
if ( handle == IntPtr.Zero )
return false;
createdNew = (error != ERROR_ALREADY_E XISTS);
return true;
}
static void Print(string format,params object[] args)
{
string msg = string.Format(f ormat,args);
Trace.WriteLine (msg);
Console.WriteLi ne(msg);
}
}
}
"Chris B" <Ch****@discuss ions.microsoft. com> wrote in message
news:B6******** *************** ***********@mic rosoft.com...
I have the following situation:
Process 1 creates Process 2 (using Process.Start(s tartInfo)
Process 1 needs to wait until Process 2 is initialized before Process 1
can continue to execute Both processes are non-GUI processes.
The problem that I am running into is that the Process.Start(s tartInfo)
returns immediately to Process 1. Therefore, process 1 does not wait on its
own for Process 2 to initialize.
Process 2 can take a few seconds to intialize. Process 1 needs to halt
its execution until Process 2 is initialized. How can process 1 and 2
signal eachother to accomplish what I'm after?
In process 1 I tried using a Mutex:
Process process = Process.Start(s tartInfo);
if (process != null)
{
Mutex m = new Mutex(false, "Mutex");
m.WaitOne();
...
}
Process 2:
Main...
{
bool mutexWasCreated = false;
Mutex m = new Mutex(true, "Mutex", out mutexWasCreated );
if (mutexWasCreate d)
{
...
m.ReleaseMutex( );
}
}
this doesn't come close to working because process 1 gets the mutex before
process 2 can acquire the lock. What I need is the ability to have process
1 wait on a mutex, have process 2 acquire the mutex lock, do its
initialization, then release the mutex, then process 1 resumes execution.
I have gotten the above to work in C++ using the CreateEvent API. Process
1 creates an unsignaled event, process 1 launches process 2, process 1 waits
on the event, process 2 does its thing, process 2 signals the event, process
1 continues.
How can I do this in C#?
Thanks!
