operate winform application twice

Just remove the single instance limitation and be done with it. Why do we limit applications to single instance? Because it makes sense doesn't cut it. The reasons to limit an application to a single instance are finite, but the requests to do so are ubiquitous. That tells me it's being overused.

Do you really care if the application is started 100 times? Do yourself a favor: remove the constraint and spend your programming time elsewhere.

Most likely, this code is designed to keep number of instances 0 to 1; more exactly, second instance of loading runs for a short time until it discovers that the first instance is already running, to terminate immediately. If you remove this code, you will be able load your application any number of times, but you cannot make this number, say, 3 or 4 and no more. Without looking at the code, it's hard to say how to modify it; and most likely it would not make any sense.

What happens with you is the usual consequence of using some other person's code without understanding how it works. And then you try to modify behavior using trial-end-error, blind-folded approach. This is not how such things can be achieved.

Most likely, you will need to write a brand new code to achieve what you want. But first think if you really need it and why. There is a number of ways to limit number of application instances during run time. One simple approach is this: in your application, run System.Diagnostics.Process.GetProcessesByName(string) using the name of current process. Some of such processes can have the same name by coincidence, so examine Process.MainModule for each process and System.Diagnostics.ProcessModule.FileName to make sure it is loaded from the same executable file, in your case, same as main executable module of your entry assembly.

Based on this information, calculate the total number of processes running a separate instance of your application and decide if you want to run another one. If not, terminate your current process immediately.

See:
http://msdn.microsoft.com/en-us/library/system.diagnostics.process.aspx[^],
http://msdn.microsoft.com/en-us/library/system.diagnostics.processmodule.aspx[^].

—SA

Where a Mutex is used to allow single access to a resource, a System.Threading.Semaphore can allow multiple access. The coding is very similar e.g.

internal sealed class Limiter {
  private const String SemaphoreName = "AARDVARK.Samphire";
  private const Int32 HardCodedLimit = 2;
  private Semaphore sem;

  internal Limiter() {
    sem = new Semaphore(HardCodedLimit, HardCodedLimit, SemaphoreName);
  }

  internal Boolean PermissionGranted() {
    return sem.WaitOne(0);
  }

  internal void Release() {
    sem.Release();
  }
}

and then use to control application instance count

private static Limiter limiter;

[STAThread]
internal static void Main() {
  // Limited instance count
  limiter = new Limiter();
  if (limiter.PermissionGranted()) {
    Application.Run(new Form1());
    limiter.Release();
  } else {
    MessageBox.Show("No");
  }
}

I've never done this myself but that's the general idea.

Alan.