WCF Named Pipes across the user session on same machine. Possible?

Question

Requirement I am trying to create a "Single Instance" winforms app with args to be passed if second instance invoked. I hope Mutex will not work like this. I have made a WCF pipe on the winform app so that if another instance came, it will be notified to Main Instance with the required args which I will process the args on the Main Instance as required and second instance closed after notifying.

Issue: The above code seems to be working fine, problem arises when it comes to multiple user session, When I logon to the machine as "User A" and opens my app, it opens up the app (Main instance). At the same time, if another user logon say "User B" and tries to open up the app, IT HAPPILY OPENS UP :(

Code:

Here is my code for single instance with WCF.

public static class SingleInstanceManager
{
    /// <summary>
    /// Raised when another instance attempts to start up.
    /// </summary>
    public static event StartupEventHandler OtherInstanceStarted;

    /// <summary>
    /// Checks to see if this instance is the first instance running on this machine.  If it is not, this method will
    /// send the main instance this instance's startup information.
    /// </summary>
    /// <param name="guid">The application's unique identifier.</param>
    /// <returns>True if this instance is the main instance.</returns>
    public static bool VerifySingleInstance(Guid guid)
    {
        if (!AttemptPublishService(guid))
        {
            NotifyMainInstance(guid);

            return false;
        }

        return true;
    }

    /// <summary>
    /// Attempts to publish the service.
    /// </summary>
    /// <param name="guid">The application's unique identifier.</param>
    /// <returns>True if the service was published successfully.</returns>
    private static bool AttemptPublishService(Guid guid)
    {
        try
        {
            ServiceHost serviceHost = new ServiceHost(typeof(SingleInstance));
            NetNamedPipeBinding binding = new NetNamedPipeBinding(NetNamedPipeSecurityMode.None);
            serviceHost.AddServiceEndpoint(typeof(ISingleInstance), binding, CreateAddress(guid));
            serviceHost.Open();

            return true;
        }
        catch
        {
            return false;
        }
    }

    /// <summary>
    /// Notifies the main instance that this instance is attempting to start up.
    /// </summary>
    /// <param name="guid">The application's unique identifier.</param>
    private static void NotifyMainInstance(Guid guid)
    {
        NetNamedPipeBinding binding = new NetNamedPipeBinding(NetNamedPipeSecurityMode.None);
        EndpointAddress remoteAddress = new EndpointAddress(CreateAddress(guid));
        using (ChannelFactory<ISingleInstance> factory = new ChannelFactory<ISingleInstance>(binding, remoteAddress))
        {
            ISingleInstance singleInstance = factory.CreateChannel();
            singleInstance.NotifyMainInstance(Environment.GetCommandLineArgs());
        }
    }

    /// <summary>
    /// Creates an address to publish/contact the service at based on a globally unique identifier.
    /// </summary>
    /// <param name="guid">The identifier for the application.</param>
    /// <returns>The address to publish/contact the service.</returns>
    private static string CreateAddress(Guid guid)
    {
        return string.Format(CultureInfo.CurrentCulture, "net.pipe://localhost/{0}", guid);
    }

    /// <summary>
    /// The interface that describes the single instance service.
    /// </summary>
    [ServiceContract]
    private interface ISingleInstance
    {
        /// <summary>
        /// Notifies the main instance that another instance of the application attempted to start.
        /// </summary>
        /// <param name="args">The other instance's command-line arguments.</param>
        [OperationContract]
        void NotifyMainInstance(string[] args);
    }

    /// <summary>
    /// The implementation of the single instance service interface.
    /// </summary>
    private class SingleInstance : ISingleInstance
    {
        /// <summary>
        /// Notifies the main instance that another instance of the application attempted to start.
        /// </summary>
        /// <param name="args">The other instance's command-line arguments.</param>
        public void NotifyMainInstance(string[] args)
        {
            if (OtherInstanceStarted != null)
            {
                Type type = typeof(StartupEventArgs);
                ConstructorInfo constructor = type.GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
                StartupEventArgs e = (StartupEventArgs)constructor.Invoke(null);
                FieldInfo argsField = type.GetField("_args", BindingFlags.Instance | BindingFlags.NonPublic);
                Debug.Assert(argsField != null);
                argsField.SetValue(e, args);

                OtherInstanceStarted(null, e);
            }
        }
    }
}

On the Winforms Main:

static void Main()
{
  //bool isSingle;
  //var mut = new Mutex(true, "MarketFeeder", out isSingle);
  var applicationId = new Guid("08f21b4e-86d7-4ddf-abcb-9a72cd2bbd4f");

   if (SingleInstanceManager.VerifySingleInstance(applicationId))
    {
        SingleInstanceManager.OtherInstanceStarted += OnOtherInstanceStarted;
            // Start the application

        System.Windows.Forms.Application.EnableVisualStyles();
        System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(false);
        main = new MainForm();
        System.Windows.Forms.Application.Run(main);
    }     

}

Help needed on

Is there a way to communicate via Namedpipe across the users on same machine?, I don't want to go for "Windows service" for my requirement which I feel over kill for my requirement.

Already went though following links but no luck. Also they are too old I feel we have better solution for this in recent times. I hope there are some devs like me who are still working on Windows applications :P

Isolated Named Pipes in Terminal Server Sessions