Winform Single Instance using mutex

Question

0.00/5 (No votes)

See more:

I have a winform application that opens other winform objects. I need a way to limiting the number of instances of these other winform objects to one. I understand mutexs. But I don't know how to override the winform object to one instance. Note I am not asking about the applications itself.

Posted 24-Feb-11 5:21am

John Robert Wilk

Add a Solution

3 solutions

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Member 16134338 · Answer 1 · 2023-11-06T23:46:00

#include "main_form.h"

using namespace System;
using namespace System::Windows::Forms;
using System::Threading::Mutex;

[STAThread]
int main(array<String^>^ args)
{
	// Set this variable to false if you do not want to request 
	// initial ownership of the named mutex.
	bool requestInitialOwnership = true;
	bool mutexWasCreated = false;

	// Request initial ownership of the named mutex by passing
    // true for the first parameter. Only one system object named 
    // "MutexGUI" can exist; the local Mutex object represents 
    // this system object. If "MutexGUI" is created by this call,
    // then mutexWasCreated contains true; otherwise, it contains
    // false.
	Mutex^ myMutex = gcnew Mutex(requestInitialOwnership, "MutexGUI", mutexWasCreated);

	// This thread owns the mutex only if it both requested 
    // initial ownership and created the named mutex. Otherwise,
    // it can request the named mutex by calling WaitOne.
	if (!(requestInitialOwnership && mutexWasCreated))
	{
		MessageBox::Show("The application is open.", "Application ", MessageBoxButtons::OK, MessageBoxIcon::Information);

		/* Releases all resources held by the current WaitHandle element */
		myMutex->Close();
	}
	else
	{
		/*  Enabling Windows visual effects before any controls are created */
		Application::EnableVisualStyles();
		Application::SetCompatibleTextRenderingDefault(false);

		/* Create the main window and run it */
		Application::Run(gcnew NAME_PROJECT::main_form());

		myMutex->ReleaseMutex();
	}
	
	return 0;
}

Nish Nishant · Answer 2 · 2011-02-24T05:44:00

Are you sure you want this in C++/CLI? If so, here's a singleton form implementation that uses C++/CLI syntax:

MC++

public ref class SingletonForm : public System::Windows::Forms::Form
{
public:
  static property SingletonForm^ Instance
  {
    SingletonForm^ get()
    {
      return instance == nullptr ? instance = gcnew SingletonForm() : instance;
    }
  }

private:
  SingletonForm(void)
  {
    InitializeComponent();
  }

protected:
  ~SingletonForm()
  {
    if (components)
    {
      delete components;
    }
  }

private:
  static SingletonForm^ instance;
  System::ComponentModel::Container ^components;
}

And you would use it thus:

MC++

SingletonForm::Instance->Show();

#realJSOP · Answer 3 · 2011-02-24T05:27:00

I think this is how you'd do it.

C++

public partial class CSingletonForm : Form
{
    public:
        static CSingletonForm& Instance()
        {
            static CSingletonForm singleton;
            return singleton;
        }

    // Other non-static member functions
    private:
        CSingletonForm() {};                                   // Private constructor
        CSingletonForm(const CSingletonForm&);                 // Prevent copy-construction
        CSingletonForm& operator=(const CSingletonForm&);      // Prevent assignment
};

And then inherit from that object.

Winform Single Instance using mutex

3 solutions

Solution 3

Solution 2

Solution 1

Add your solution here

Preview 0