using System;
using System.IO;
using System.IO.Pipes;
using System.Security.AccessControl;
using System.Security.Principal;

namespace ProcessSingleInstance
{
  class Program
  {
    static void Main(string[] args)
    {
      string[] data = new[] { "a", "aaaaa", "qweqeqweqeqweqwert" };

      NamedPipeServerStream server = null;
      try
      {
        server = CreateServerStream();
      }
      catch (UnauthorizedAccessException)
      {
      }

      if (server != null)
      {
        RunServer(server);
      }
      else
      {
        RunClient(data);
      }
    }

    // критиковать здесь.
    // Сервер должен _только_ читать данные;
    // не должен позволять соединения вне текущей сессии, в т.ч. удалённые
    private static NamedPipeServerStream CreateServerStream()
    {
      PipeSecurity security = new PipeSecurity();

      security.AddAccessRule(
        new PipeAccessRule(
          WindowsIdentity.GetCurrent().User,
          PipeAccessRights.Synchronize
          | PipeAccessRights.ReadAttributes // DONTTOUCH: Required. I don't know why.
          | PipeAccessRights.Write,
          AccessControlType.Allow));

      NamedPipeServerStream server = new NamedPipeServerStream(
        "server",
         PipeDirection.In, 1,
         PipeTransmissionMode.Message, PipeOptions.WriteThrough, // Не уверен. Может, всё-таки использовать буфер?
         4096, 4096,
         security, HandleInheritability.None);

      return server;
    }

    // и здесь
    private static NamedPipeClientStream CreateClientStream()
    {
      NamedPipeClientStream client = new NamedPipeClientStream(
        ".", "server",
        PipeDirection.Out, PipeOptions.WriteThrough, TokenImpersonationLevel.None, HandleInheritability.None);
      
      return client;
    }

    private static void RunServer(NamedPipeServerStream server)
    {
      while (true)
      {
        Console.WriteLine("Wait...");
        BinaryReader r = new BinaryReader(server);
        server.WaitForConnection();

        try
        {
          int count = r.ReadInt32();
          for (int i = 0; i < count; i++)
          {
            Console.WriteLine(r.ReadString());
          }
        }
        catch (IOException)
        { }

        server.Disconnect();
      }
    }
    private static void RunClient(string[] data)
    {
      using (NamedPipeClientStream client = CreateClientStream())
      {
        client.Connect();
        using (BinaryWriter w = new BinaryWriter(client))
        {
          try
          {
            w.Write(data.Length);
            foreach (var item in data)
            {
              w.Write(item);
            }

            client.WaitForPipeDrain();
          }
          catch (IOException)
          { }
        }
      }
    }
  }
}

using System;
using System.ServiceModel;

namespace WCFSample
{
  [ServiceContract]
  public interface IServiceContract
  {
    [OperationContract]
    void StartOnServer(string[] args);
  }

  public class Service: IServiceContract
  {
    public void StartOnServer(string[] args)
    {
      Console.WriteLine(string.Join(",", args));
    }
  }

  class Program
  {
    static void Main(string[] args)
    {
      try
      {
        ServerStart(@"net.pipe://127.0.0.1/wtfService");
      }
      catch (AddressAlreadyInUseException)
      {
        try
        {
          ClientStart(@"net.pipe://127.0.0.1/wtfService");
        }
        catch (Exception ex)
        {
          Console.WriteLine(ex);
          Console.ReadKey();
        }
      }
    }

    private static void ServerStart(string channelUri)
    {
      ServiceHost host = new ServiceHost(typeof(Service), new Uri(channelUri));
      try
      {
        host.AddServiceEndpoint(typeof(IServiceContract),
          new NetNamedPipeBinding(NetNamedPipeSecurityMode.Transport),
          new Uri(channelUri));
        host.Open();

        Console.WriteLine("Service is ready, press any key to terminate.");
        Console.ReadKey();
        // ((Service) as Service).LaucnhStartUpWindow();
      }
      catch (CommunicationException ex)
      {
        // Console.WriteLine(ex);
        Console.WriteLine("Client starting...");
        host.Abort();
        throw;
      }
    }

    private static void ClientStart(string channelUri)
    {
      ChannelFactory<IServiceContract> factory =
        new ChannelFactory<IServiceContract>
            (new NetNamedPipeBinding(), new EndpointAddress(channelUri));
      IServiceContract proxy = factory.CreateChannel();

      try
      {
        //signal server that a new instance is selected
        proxy.StartOnServer(new[] { "Hello", "world" });
      }
      catch (EndpointNotFoundException ex)
      {
        Console.WriteLine(ex);
        //return false to indicate this instance is first instance
        // return false;
      }
    }
  }
}