Type a page name and press Enter. You'll jump to the page if it exists, or you can create it if it doesn't.
To create a page in a module other than kernel32, prefix the name with the module name and a period.

Sample C# class:

The following class object provides some interprocess event signaling style synchronization within the .NET environment. Specifically, using named events, processes can signal each other out of an effecient wait. This reach goes beyond .NET can allow .NET and Win32 processes to signal each other. There are some security issues, in that the default security context of the process is used.

NOTE: This class needs some changes. The CloseHandle call will destroy the event when the last handle is closed. This makes it hard for one application to "lock" the event while making another wait on it since this class is always closing the handle. An alternative that I found to work is to have the CreateEvent call in the constructor and implement IDisposable by moving the CloseHandle call to the Dispose method.

using System;
using System.Runtime.InteropServices;

namespace Utilities
{
/// <summary>
/// The NamedEvent class is to suppliment .NET's event classes with the ability to span
/// processes in both .NET and Win32 with the same event signaling capability.
///
/// The NamedEvent class object provides the ability to wait on, pulse, set, and
/// reset a named event. The event can be created with manual or automatic reset,
/// and is always created with an initial state of reset(false).
///
/// The NamedEvent class will not leave a handle open past any method
/// call, so garbage collection is irrelevant.
///
/// The NamedEvent class defines both instance methods and static methods.
/// The static methods require a name, where as the instance methods contain the
/// name in the object instance already. The static methods are also limited to
/// the configuration of auto reset and initially not signaled.
///
/// The wait methods will wait on a single object, the named event, only. There
/// is no multiple event support.
///
/// Win32 security is a critical issue. This class does not support specifically
/// identifying any security, other than the default process security context.
/// This class is best suitable for processes run in the same security context,
/// such as the desktop's interactive user account.
/// </summary>

/// <summary>
/// Create a NamedEvent object with the name of the event, and assume auto reset with
/// an initial state of reset.
/// </summary>
public NamedEvent(string EventName ) : this( EventName, false ) {}

/// <summary>
/// Set the named event to a signaled state. The Wait() method will not block any
/// thread as long as the event is in a signaled state.
/// </summary>
public void Set()
{
_Handle = CreateEvent( _Attributes, _ManualReset, _InitialState, _EventName );
SetEvent( _Handle );
CloseHandle( _Handle );
}

/// <summary>
/// Reset the named event to a non signaled state. The Wait() method will block
/// any thread that enters it as long as the event is in a non signaled state.
/// </summary>
public void Reset()
{
_Handle = CreateEvent( _Attributes, _ManualReset, _InitialState, _EventName );
ResetEvent( _Handle );
CloseHandle( _Handle );
}

/// <summary>
/// Wait for the event with the given name to signal to a maximum period of TimeoutInSecs total seconds.
/// Returns true if the event signaled, false if timeout occurred.
/// </summary>
static public bool Wait( int TimeoutInSecs, string Name )
{
return (new NamedEvent(Name)).Wait( TimeoutInSecs );
}

/// <summary>
/// Pulse the event with the given name, which results in a single waiting thread to exit the Wait method.
/// </summary>
static public bool Pulse(string Name) { return (new NamedEvent(Name)).Pulse(); }

/// <summary>
/// Set the event with the given name to a signaled state. The Wait() method will not block
/// any threads as long as the event is in a signaled state.
/// </summary>
static public void Set(string Name) { (new NamedEvent(Name)).Set(); }

/// <summary>
/// Reset the event with the given name to a non signaled state. The Wait() method will block
/// any thread that enters it as long as the event is in a non signaled state.
/// </summary>
static public void Reset( string Name) { (new NamedEvent(Name)).Reset(); }
}
}

Alternative Managed API:

Do you know one? Please contribute it!

I think that in .NET 2.0 the System.Threading.EventWaitHandle class does the same that the example.