Try creating a class called AppMessenger

using System;
using System.Runtime.InteropServices;
using System.Diagnostics;
using System.IO;

namespace Messenger
{
   /// <summary>
   /// The problem with using command line parameters for any
applications is that a new
   /// instance of the application is started. For some apps it would
be preferable if
   /// there was only one instance of the app and the command line
could be forwarded
   /// back to the previous instance of the app.
   ///
   /// This can be done by looking for a previous instance of the
app, sending a
   /// WM_COPYDATA message to that previous instance and exiting (if
it is found). If it
   /// is not found then the application can start normally. This is
the technique used
   /// by MS Word and other applications.
   /// </summary>
   public class AppMessenger
   {
       //Pick any number at random. This number will be used to
uniquely identify the message
       private static int _messageID = -1163005939;
       //this message will used to send the commandline to the
previous instance of the app
       public const int WM_COPYDATA = 0x4A;
       //API call to send WM_COPYDATA to the previous instance of the
app
       [DllImport("user32", EntryPoint = "SendMessageA")]
       private static extern int SendMessage(IntPtr hWnd, int wMsg,
int wParam, COPYDATASTRUCT lParam);

       //all members of this class are static so do not allow an
instance to be created
       private AppMessenger()
       {
       }

       /// <summary>
       /// Checks for a previous instance of this app and forwards
the
       /// command line to this instance if found.
       /// </summary>
       /// <returns>
       /// True if a previous instance was found.
       /// </returns>
       public static bool CheckPrevInstance()
       {
           IntPtr hWnd =
GetHWndOfPrevInstance(Process.GetCurrentProcess().ProcessName);
           if (hWnd != IntPtr.Zero)
           {
               SendCommandLine(hWnd, Environment.CommandLine);
               return true;
           }
           return false;
       }

       public static bool SendMessageToApp(string FileName, string
Message)
       {
           IntPtr hWnd =
GetHWndOfPrevInstance(GetFileNameFromFullName(FileName));
           if (hWnd != IntPtr.Zero)
           {
               SendCommandLine(hWnd, Message);
               return true;
           }
           //could not find process so start it
           Process P = new Process();
           P.StartInfo.FileName = FileName;
           P.Start();
           int t = Environment.TickCount + 30000;//30 second timeout
           do
           {
               try
               {
                   hWnd = P.MainWindowHandle;
               }
               catch//ignore errors
               {
               }
           } while (hWnd == IntPtr.Zero && t <
Environment.TickCount);
           if (hWnd != IntPtr.Zero)
           {
               SendCommandLine(hWnd, Message);
               return true;
           }
           return false;
       }

       private static string GetFileNameFromFullName(string FullName)
       {
           int pos = FullName.LastIndexOf("\\");
           if (pos >= 0)
           {
               return FullName.Substring(pos + 1);
           }
           else
           {
               return FullName;
           }
       }

       /// <summary>
       /// Searches for a previous instance of this app.
       /// </summary>
       /// <returns>
       /// hWnd of the main window of the previous instance
       /// or IntPtr.Zero if not found.
       /// </returns>
       private static IntPtr GetHWndOfPrevInstance(string
ProcessName)
       {
           //get the current process
           Process CurrentProcess = Process.GetCurrentProcess();
           //get a collection of the currently active processes with
the same name
           Process[] Ps = Process.GetProcessesByName(ProcessName);
           //if only one exists then there is no previous instance
           if (Ps.Length > 1)
           {
               foreach (Process P in Ps)
               {
                   if (P.Id != CurrentProcess.Id)//ignore this
process
                   {
                       //weed out apps that have the same exe name
but are started from a different filename.
                       if (P.ProcessName == ProcessName)
                       {
                           IntPtr hWnd = IntPtr.Zero;
                           try
                           {
                               //if process does not have a
MainWindowHandle then an exception will be thrown
                               //so catch and ignore the error.
                               hWnd = P.MainWindowHandle;
                           }
                           catch { }
                           //return if hWnd found.
                           if (hWnd.ToInt32() != 0) return hWnd;
                       }
                   }
               }
           }
           return IntPtr.Zero;
       }

       /// <summary>
       /// Sends command line to a previous instance of this app
       /// </summary>
       /// <param name="hWnd">Main Window handle of the previous
instance of this app. Found using the function
GetHWndOfPrevInstance()</param>
       /// <param name="CommandLine">CommandLine or message to send</
param>
       private static void SendCommandLine(IntPtr hWnd, string
CommandLine)
       {
           SendMessage(hWnd, WM_COPYDATA, _messageID, new
COPYDATASTRUCT(Environment.CommandLine));
       }

       /// <summary>
       /// Processes WM_COPYDATA message sent to the main window of
this app
       /// </summary>
       /// <param name="m">Message sent to the main window of this
app</param>
       /// <returns>Message received or null if messageID is not
valid</returns>
       public static string
ProcessWM_COPYDATA(System.Windows.Forms.Message m)
       {
           if (m.WParam.ToInt32() == _messageID)
           {
               COPYDATASTRUCT st =
(COPYDATASTRUCT)Marshal.PtrToStructure(m.LParam,
typeof(COPYDATASTRUCT));
               return st.lpData;
           }
           return null;
       }

       /// <summary>
       /// Structure required to be sent with the WM_COPYDATA message
       /// This structure is used to contain the CommandLine
       /// </summary>
       [StructLayout(LayoutKind.Sequential)]
       public class COPYDATASTRUCT
       {
           public int dwData = 0;//32 bit int to passed. Not used.
           public int cbData = 0;//length of string. Will be one
greater because of null termination.
           public string lpData;//string to be passed.

           public COPYDATASTRUCT()
           {
           }

           public COPYDATASTRUCT(string Data)
           {
               lpData = Data + "\0";   //add null termination
               cbData = lpData.Length; //length includes null chr so
will be one greater
           }
       }
   }
}

Then in your MainForm's constructor add this before
InitializeComponent:

          if (Messenger.AppMessenger.CheckPrevInstance())
           {
              Application.Exit();
              this.Close();
           }
           else
           {
               InitializeComponent();

              //Command-Line
               string[] Command = Environment.GetCommandLineArgs();
               if (Command.Length > 1)
                   processCommandLine(Command);
             }

protected override void WndProc(ref Message m)
       {
           if (m.Msg == Messenger.AppMessenger.WM_COPYDATA)
           {
               string command =
Messenger.AppMessenger.ProcessWM_COPYDATA(m);
               if (command != null)
               {

                   processCommandLine(command);
                   return;
               }
           }
           base.WndProc(ref m);
       }

       private void processCommandLine(string CommandLine)
       {

         //do whatever you want to do..................

       }

And be sure to add a try/catch in Program.cs like so:

static void Main()
       {
           try
           {
               Application.Run(new MainForm());
           }catch (Exception ex) { }

       }