PipeClient 2.0.2.5

Pipe Client

A Client for inter-process communication over a named pipe using a shared secret to execute a Handler

The Client sends Data to the Server so the Server can execute the Handler

Data is string

using Pipe.Com;
using PipeClientRPC;
using System.IO.Pipes;

namespace PipeClientConsole
{
    internal class PipeClientConsole
    {
        readonly static bool switchTest = true;

        static string path = "C:\\Windows\\notepad.exe";
        static string secret = "SDh&SarvecGr!eCtn@";
        static string pipeName = "testpipe";
        static string serverName = ".";

        static void Main()
        {
            bool success;

            if (switchTest)
            {
                success = PipeClient.Request(BackAndForthTest, secret, pipeName, serverName);
            }
            else
            {
                success = PipeClient.Request(ApplicationTest, secret, pipeName, serverName);
            }

            Console.WriteLine(success);
        }

        private static bool ApplicationTest(NamedPipeClientStream clientStream)
        {
            return new PipeMessage(clientStream).WriteStringWaitForRead(path) == C.SUCCESS;
        }

        private static bool BackAndForthTest(NamedPipeClientStream clientStream)
        {
            string serverResponse = new PipeMessage(clientStream).WriteStringWaitForRead("DidYouGetThis");

            if (serverResponse != null && serverResponse != C.FAILED)
            {
                try
                {
                    Console.WriteLine("Server Said: " + serverResponse);
                }
                catch
                {
                    return false;
                }

                return true;
            }

            return false;
        }
    }
}

Pipe Server

You need the PipeServer to use this

using Pipe.Com;
using PipeServerRPC;
using System.Diagnostics;
using System.IO.Pipes;

namespace PipeServerConsole
{
    internal class PipeServerConsole
    {
        readonly static bool switchTest = true;

        static readonly PipeServer PipeServer = new("testpipe", "SDh&SarvecGr!eCtn@");

        static void Main()
        {
            Console.WriteLine(PipeApplicationGlobals.ElapsedTicks);

            PipeApplicationGlobals.SetTimeoutMs(500);

            if (switchTest)
            {
                ThreadPool.QueueUserWorkItem((_) => { PipeServer.Start(BackAndForthTest); }, null);
            }
            else
            {
                ThreadPool.QueueUserWorkItem((_) => { PipeServer.Start(ApplicationTest); }, null);
            }

            Console.WriteLine("Press any key to dispose server");

            Console.ReadLine();

            PipeServer.Dispose();

            Console.WriteLine("Press any key to exit");

            Console.ReadLine();
        }

        public static void BackAndForthTest(NamedPipeServerStream serverStream, string clientWord)
        {
            string handlerResponse;

            if (clientWord == "DidYouGetThis")
            {
                handlerResponse = "Yes, I got that";
            }
            else
            {
                handlerResponse = "No, What you said is wrong";
            }

            if (!string.IsNullOrWhiteSpace(handlerResponse))
            {
                new PipeMessage(serverStream).WriteString(handlerResponse);
            }
            else
            {
                new PipeMessage(serverStream).WriteString(C.N);
            }
        }

        private static void ApplicationTest(NamedPipeServerStream serverStream, string clientResponse)
        {
            try
            {
                ProcessStartInfo psi = new()
                {
                    FileName = clientResponse,
                    UseShellExecute = true,
                    RedirectStandardError = false,
                    RedirectStandardOutput = false,
                    RedirectStandardInput = false,
                };

                Process.Start(psi);
            }
            catch
            {

            }

            new PipeMessage(serverStream).WriteString(C.SUCCESS);
        }
    }
}