C# NamedPipe

using System;
using System.IO;
using System.IO.Pipes;
using System.Threading;
using System.Diagnostics;
using System.Collections.Generic;
using System.Text;

namespace Protector
{
    public class Protector
    {
        private Thread serverThread;
        private Dictionary<string, Process> dict;
        private Timer timer;

        public Protector()
        {
            serverThread = new Thread(() =>
            {
                while (true)
                {
                    using (NamedPipeServerStream pipeServer = new NamedPipeServerStream("ProtectorPipe", PipeDirection.In))
                    using (BinaryReader reader = new BinaryReader(pipeServer))
                    {
                        pipeServer.WaitForConnection();
                        string value = reader.ReadString();
                        Console.WriteLine(value);
                        RegisterProcess(value);
                        pipeServer.Disconnect();
                    }
                }
            });
            serverThread.IsBackground = true;
            serverThread.Start();
        }

        public void RegisterProcess(string filePath)
        {
            if (File.Exists(filePath))
            {
                if (dict == null)
                {
                    dict = new Dictionary<string, Process>(1);
                    timer = new Timer(CheckProcess, null, 200, 200);
                }
                if (!dict.ContainsKey(filePath))
                {
                    dict.Add(filePath, GetProcess(filePath) ?? new Process());
                }
            }
        }
        private void CheckProcess(object obj)
        {
            foreach (KeyValuePair<string, Process> pair in dict)
            {
                string filePath = pair.Key;
                if (GetProcess(filePath) == null)
                {
                    Process processObj = pair.Value;
                    processObj.StartInfo.FileName = filePath;
                    processObj.EnableRaisingEvents = true;
                    processObj.Exited += new EventHandler(processObj_Exited);
                    processObj.Start();
                    Thread.Sleep(0x7d0);
                }
            }
        }
        private void processObj_Exited(object sender, EventArgs e)
        {
            Process processObj = (Process)sender;
            try
            {
                processObj.WaitForExit();
            }
            finally
            {
                string filePath = processObj.StartInfo.FileName;
                if (GetProcess(filePath) == null)
                {
                    processObj.Refresh();
                    processObj.StartInfo.FileName = filePath;
                    processObj.EnableRaisingEvents = true;
                    processObj.Exited += new EventHandler(processObj_Exited);
                    processObj.Start();
                    Thread.Sleep(0x7d0);
                }
            }
        }

        public Process GetProcess(string filePath)
        {
            Process[] p = Process.GetProcessesByName(Path.GetFileNameWithoutExtension(filePath));
            return p.Length > 0 ? p[0] : null;
        }
    }
}

        public static bool TryProtectProcess(string filePath)
        {
            Guard<FileNotFoundException>(!File.Exists(filePath), "filePath");
            try
            {
                using (NamedPipeClientStream pipeClient = new NamedPipeClientStream(".", "ProtectorPipe", PipeDirection.Out))
                using (BinaryWriter writer = new BinaryWriter(pipeClient))
                {
                    pipeClient.Connect(1000);
                    writer.Write(filePath);
                    writer.Flush();
                }
                return true;
            }
            catch (TimeoutException)
            {
                return false;
            }
            catch
            {
                throw;
            }
        }