应用程序的唯一性

来源：互联网发布：淘宝a店b店c店编辑：程序博客网时间：2024/04/29 11:21

程序启动后，如果再次启动程序，不会出现2个程序，或者实现如Notepad++已打开一个文件，再打开另外一个文件，则追加在Notepad++界面上。

使用codeproject上别人编写的一个类，加在程序启动时即可。

sinstance.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
/*
Module : SINSTANCE.H
Purpose: Defines the interface for an MFC wrapper class to do instance checking
Created: PJN / 29-07-1998
 
Copyright (c) 1996 - 2008 by PJ Naughter (Web: www.naughter.com, Email: pjna@naughter.com)
 
All rights reserved.
 
Copyright / Usage Details:
 
You are allowed to include the source code in any product (commercial, shareware, freeware or otherwise)
when your product is released in binary form. You are allowed to modify the source code in any way you want
except you cannot modify the copyright details at the top of each module. If you want to distribute source
code with your application, then you are only allowed to distribute versions released by the author. This is
to maintain a single distribution point for the source code.
 
*/
 
 
/////////////////////////// Macros / Defines //////////////////////////////////
 
#pragma once
 
#ifndef __SINSTANCE_H__
#define __SINSTANCE_H__
 
#ifndef CSINGLEINSTANCE_EXT_CLASS
#define CSINGLEINSTANCE_EXT_CLASS
#endif
 
#ifndef CSINGLEINSTANCE_EXT_API
#define CSINGLEINSTANCE_EXT_API
#endif
 
 
//////////////////////////// Includes /////////////////////////////////////////
 
#ifndef __AFXMT_H__
#pragma message("To avoid this message, please put afxmt.h in your pre compiled header (normally stdafx.h)")
#include <afxmt.h>
#endif
 
 
//////////////////////////// Classes //////////////////////////////////////////
 
class CSINGLEINSTANCE_EXT_CLASS CInstanceChecker
{
public:
//Constructors / Destructors
    CInstanceChecker(const CString& sUniqueName);
    virtual ~CInstanceChecker();
 
//General functions
    void ActivateChecker();
    BOOL TrackFirstInstanceRunning();
    BOOL PreviousInstanceRunning();
    HWND ActivatePreviousInstance(LPCTSTR lpCmdLine = NULL, ULONG_PTR dwCopyDataItemData = 0, DWORD dwTimeout = 30000);
    void QuitPreviousInstance(int nExitCode = 0);
 
protected:
//Virtual methods
    virtual CString GetMMFFilename();
    virtual HWND GetWindowToTrack();
 
//Standard non-virtual methods
  void ReleaseLock();
 
//Data
    CMutex       m_instanceDataMutex;
    CMutex       m_executeMutex;
    CSingleLock* m_pExecuteLock;
  CString      m_sName;
};
 
#endif //__SINSTANCE_H__

　　sinstance.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
/*
Module : SINSTANCE.CPP
Purpose: Defines the implementation for an MFC wrapper classe
         to do instance checking
Created: PJN / 29-07-1998
History: PJN / 25-03-2000 Neville Franks made the following changes. Contact nevf@getsoft.com, www.getsoft.com
                          1. Changed #pragma error to #pragma message. Former wouldn't compile under VC6
                          2. Replaced above #pragma with #include
                          3. Added TrackFirstInstanceRunning(), MakeMMFFilename()
         PJN / 27-03-2000 1. Fixed a potential handle leak where the file handle m_hPrevInstance was not being
                          closed under certain circumstances.
                          Neville Franks made the following changes. Contact nevf@getsoft.com, www.getsoft.com
                          2. Split PreviousInstanceRunning() up into separate functions so we
                          can call it without needing the MainFrame window.
                          3. Changed ActivatePreviousInstance() to return hWnd.
         PJN / 15-05-2000 1. Serialized access to all of the CSingleInstance class to prevent race conditions
                          which can occur when you app is programatically spawned.
         PJN / 17-05-2000 1. Updated sample to show how the code can be used for dialog based apps.
         PJN / 01-01-2001 1. Added a number of asserts to CInstanceChecker::ActivatePreviousInstance
                          2. Now includes copyright message in the source code and documentation.
         PJN / 15-01-2001 1. Now allows multiple calls to PreviousInstanceRunning without ASSERTing
                          2. Removed some unnecessary VERIFY's from ActivatePreviousInstance
                          3. Made the MMF filename used modifiable via a virtual function GetMMFFilename
                          4. Made the window to track modifiable via a virtual function GetWindowToTrack
                          5. Made destructor virtual since the introduction of other virtual functions in the class
                          6. Removed a number of unnecessary verifies
                          7. Changed the meaning of the return value from TrackFirstInstanceRunning
         PJN / 17-06-2001 1. Moved most of the code from CInstanceChecker::CInstanceChecker to
                          CInstanceChecker::ActivateChecker. This allows client code to turn on or off the instance
                          checking code easily. Thanks to Anders Rundegren for this addition.
         PJN / 31-08-2001 1. made the name of the mutex which the class uses to serialize access to itself a paramter
                          to the constructor. That way multiple independent apps do not block each other while
                          they are calling into the CSingleInstance class. Thanks to Eugene Shmelyov for spotting
                          this problem.
         PJN / 23-03-2002 1. Provided a QuitPreviousInstance method. Thanks to Jon Bennett for providing this.
         PJN / 30-10-2002 1. The name of the internal memory mapped file is now based on the Mutex name rather than
                          the application name. An example: a client was writing a webcam application and wanted it to
                          run with multiple configuration for multiple camera support. So the app can run multiple times
                          as long as a special configuration is given on the command line. But for that configuration
                          only one instance is allowed. Using the application name for the memory mapped file was tying
                          the single instance to the app rather than the unique mutex name. Thanks to Frank Fesevur for
                          this nice update.
         PJN / 06-02-2003 1. Was missing a call to ReleaseLock in CInstanceChecker::ActivatePreviousInstance. Thanks to
                          Pierrick Ingels for reporting this problem.
         PJN / 09-05-2004 1. Updated the copyright details.
                          2. Extended CInstanceChecker::ActivatePreviousInstance to now allow the command line of the
                          second app to be passed to the original app. By default the parameter is NULL, meaning that
                          you get the original behaviour which just activates the previous instance. To respond to this
                          information you should add the following to your mainfrm module:
 
                          mainfrm.h
 
                          afx_msg LRESULT OnCopyData(WPARAM, LPARAM);
 
 
                          mainfrm.cpp
 
                          LRESULT CMyFrameWnd::OnCopyData(WPARAM wParam, LPARAM lParam)
                          {
                            COPYDATASTRUCT* pCDS = reinterpret_cast<COPYDATASTRUCT*>(lParam);
                            TCHAR* pszCmdLine = static_cast<TCHAR*>(pCDS->lpData);
                            if (pszCmdLine)
                            {
                              //DO SOMETHING with pszCmdLine here such as call AfxGetApp()->OpenDocumentFile(pszCmdLine);
                            }
                            return TRUE;
                          }
 
                          Also hook up your onCopyData to the windows message map using
 
                          ON_MESSAGE(WM_COPYDATA, OnCopyData)
 
 
                          Thanks to Ingo H. de Boer for providing this nice update.
 
                          3. Following a discussion on the Codeproject.com discussion forum for CSingleInstance on what
                          exactly a single instance app means (See http://www.codeproject.com/cpp/csingleinst.asp?msg=766108#xx1103xx),
                          Daniel Lohmann has produced a simple function called CreateUniqueName which given a number of
                          settings as flags, will produce a name which is unique. This code can be downloaded at
                          http://www.losoft.de/code/SingleInstance.zip. You can then use this name in the constructor for
                          CInstanceChecker. The concept of a single instance app is complicated by the concept of Window stations
                          and desktops as used by NT Services and Windows Terminal Services. In addition you might want to allow your
                          program to be run once per user.
         PJN / 30-05-2005 1. Fix for a crash where CWnd::GetLastActivePopup can sometimes return a NULL pointer. Thanks to
                          Dominik Reichl for reporting this bug.
         PJN / 07-07-2006 1. Updated copyright details.
                          2. Addition of CSINGLEINSTANCE_EXT_CLASS and CSINGLEINSTANCE_EXT_API which allows the class to be easily used
                          in an extension DLL.
                          3. Removed derivation from CObject as it was not really needed.
                          4. Updated the documentation to use the same style as the web site.
                          5. Code now uses newer C++ style casts instead of C style casts.
                          6. Fixed a number of level 4 warnings in the sample app.
                          7. Updated code to compile cleanly using VC 2005.
         PJN / 17-03-2007 1. Updated copyright details.
                          2. Optimized _INSTANCE_DATA constructor code
                          3. Reworked how the method CInstanceChecker::GetMMFFilename creates the name of the memory mapped filename
                          the code requires for sharing. Now the main instance name appears before the hard coded string. This
                          ensures that the CInstanceChecker class works correctly for terminal sessions i.e. kernel objects prefixed
                          with the value "Local\". Thanks to Mathias Berchtold for reporting this issue.
                          4. Updated the sample app code to clean compile on VC 2005
                          5. QuitPreviousInstance now uses GetLastActivePopup API to ensure it posts the WM_QUIT message to the
                          correct window of the previous instance.
         PJN / 02-02-2008 1. Updated copyright details
                          2. Removed VC 6 style classwizard comments from the sample apps code
                          3. Updated ActivatePreviousInstance method to support Win64 compliant data
                          4. ActivatePreviousInstance now takes a "dwTimeout" parameter which it now uses internally as the timeout when
                          calling SendMessageTimeout instead of SendMessage. The code now uses SendMessageTimeout instead of SendMessage
                          to ensure we do not hang if the previous instance itself is hung. Thanks to Paul Shore for suggesting this
                          update.
                          5. Updated the sample apps to clean compile on VC 2008
 
Copyright (c) 1996 - 2008 by PJ Naughter (Web: www.naughter.com, Email: pjna@naughter.com)
 
All rights reserved.
 
Copyright / Usage Details:
 
You are allowed to include the source code in any product (commercial, shareware, freeware or otherwise)
when your product is released in binary form. You are allowed to modify the source code in any way you want
except you cannot modify the copyright details at the top of each module. If you want to distribute source
code with your application, then you are only allowed to distribute versions released by the author. This is
to maintain a single distribution point for the source code.
 
*/
 
 
/////////////////////////////////  Includes  //////////////////////////////////
 
#include "stdafx.h"
#include "sinstance.h"
 
 
/////////////////////////////// Defines / Macros //////////////////////////////
 
#ifdef _DEBUG
#define new DEBUG_NEW
#endif
 
 
///////////////////////////////// Implementation //////////////////////////////
 
//struct which is put into shared memory
struct CWindowInstance
{
  HWND hMainWnd;
};
 
//Class which is used as a static to ensure that we
//only close the file mapping at the very last chance
class _SINSTANCE_DATA
{
public:
//Constructors / Destructors
  _SINSTANCE_DATA();
  ~_SINSTANCE_DATA();
 
protected:
//Member variables
  HANDLE hInstanceData;
 
  friend class CInstanceChecker;
};
 
_SINSTANCE_DATA::_SINSTANCE_DATA() : hInstanceData(NULL)
{
}
 
_SINSTANCE_DATA::~_SINSTANCE_DATA()
{
  if (hInstanceData != NULL)
  {
    ::CloseHandle(hInstanceData);
    hInstanceData = NULL;
  }
}
 
static _SINSTANCE_DATA g_sinstanceData;
 
 
CInstanceChecker::CInstanceChecker(const CString& sUniqueName) : m_executeMutex(FALSE, sUniqueName)
{
  //Hive away the unique name as we will also be using it for the name of the memory mapped file
  m_sName = sUniqueName;
 
  //Only one object of type CInstanceChecker should be created
  ASSERT(g_sinstanceData.hInstanceData == NULL);
  m_pExecuteLock = NULL;
}
 
void CInstanceChecker::ActivateChecker()
{
  ASSERT(m_pExecuteLock == NULL);
 
  //Ensure there is only ever one CInstanceChecker instance
  //active at any one time throughout the system
  m_pExecuteLock = new CSingleLock(&m_executeMutex, TRUE);
}
 
CInstanceChecker::~CInstanceChecker()
{
  //Free up the instance lock
  ReleaseLock();
}
 
void CInstanceChecker::ReleaseLock()
{
  if (m_pExecuteLock)
  {
    delete m_pExecuteLock;
    m_pExecuteLock = NULL;
  } 
}
 
//Track the first instance of our App.
//return TRUE on success, else FALSE
BOOL CInstanceChecker::TrackFirstInstanceRunning()
{
  //If a previous instance is running, just return prematurely
  if (PreviousInstanceRunning())
    return FALSE;
 
  //If this is the first instance then copy in our info into the shared memory
 
  //First create the MMF
  int nMMFSize = sizeof(CWindowInstance);
  g_sinstanceData.hInstanceData = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, nMMFSize, GetMMFFilename());
  if (g_sinstanceData.hInstanceData == NULL)
  {
    TRACE(_T("Failed to create the MMF even though this is the first instance, you might want to consider overriding GetMMFFilename()\n"));
    return FALSE;
  }
 
  //Open the MMF
  CWindowInstance* pInstanceData = static_cast<CWindowInstance*>(MapViewOfFile(g_sinstanceData.hInstanceData, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, nMMFSize));
  ASSERT(pInstanceData != NULL);   //Opening the MMF should work
 
  //Lock the data prior to updating it
  CSingleLock dataLock(&m_instanceDataMutex, TRUE);
  pInstanceData->hMainWnd = GetWindowToTrack();
  UnmapViewOfFile(pInstanceData);
 
  //Since this will be the last function that will be called
  //when this is the first instance we can release the lock
  ReleaseLock();
 
  return TRUE;
}
 
// Returns TRUE if a previous instance of the App is running.
BOOL CInstanceChecker::PreviousInstanceRunning()
{
  //Try to open the MMF first to see if we are the second instance
  HANDLE hPrevInstance = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, GetMMFFilename());
  BOOL bPreviousInstance = (hPrevInstance != NULL);
  if (hPrevInstance)
    CloseHandle(hPrevInstance);
 
  return bPreviousInstance;
}
 
CString CInstanceChecker::GetMMFFilename()
{
  CString sMMF(m_sName);
  sMMF += _T("_CInstanceChecker_MMF");
  return sMMF;
}
 
HWND CInstanceChecker::GetWindowToTrack()
{
  //By default the window tracked will be the standard AfxGetMainWnd()
  ASSERT(AfxGetMainWnd() != NULL); //Did you forget to set up the mainfrm in InitInstance ?
  return AfxGetMainWnd()->GetSafeHwnd();
}
 
//Activate the Previous Instance of our Application.
HWND CInstanceChecker::ActivatePreviousInstance(LPCTSTR lpCmdLine, ULONG_PTR dwCopyDataItemData, DWORD dwTimeout)
{
  //What will be the return value from this function (assume the worst)
  HWND hWindow = NULL;
 
  //Try to open the previous instances MMF
  HANDLE hPrevInstance = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, GetMMFFilename());
  if (hPrevInstance)
  {
    //Open up the MMF
    int nMMFSize = sizeof(CWindowInstance);
    CWindowInstance* pInstanceData = static_cast<CWindowInstance*>(MapViewOfFile(hPrevInstance, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, nMMFSize));
    if (pInstanceData) //Opening the MMF should work
    {
      //Lock the data prior to reading from it
      CSingleLock dataLock(&m_instanceDataMutex, TRUE);
 
      //activate the old window
      ASSERT(pInstanceData->hMainWnd); //Something gone wrong with the MMF
      hWindow = pInstanceData->hMainWnd;
      if (hWindow)
      {
        CWnd wndPrev;
        wndPrev.Attach(hWindow);
        CWnd* pWndChild = wndPrev.GetLastActivePopup();
 
        //Restore the focus to the previous instance and bring it to the foreground
        if (wndPrev.IsIconic())
          wndPrev.ShowWindow(SW_RESTORE);
 
        if (pWndChild)
          pWndChild->SetForegroundWindow();
 
        if (lpCmdLine)
        { 
          //Send the current apps command line to the previous instance using WM_COPYDATA
          COPYDATASTRUCT cds;
          cds.dwData = dwCopyDataItemData;
          DWORD dwCmdLength = static_cast<DWORD>(_tcslen(lpCmdLine) + 1);
          cds.cbData = dwCmdLength * sizeof(TCHAR);
          TCHAR* pszLocalCmdLine = new TCHAR[dwCmdLength]; //We use a local buffer so that we can specify a constant parameter
                                                           //to this function
        #if (_MSC_VER >= 1400)
          _tcscpy_s(pszLocalCmdLine, dwCmdLength, lpCmdLine);
        #else                                                
          _tcscpy(pszLocalCmdLine, lpCmdLine);
        #endif
          cds.lpData = pszLocalCmdLine;
          CWnd* pMainWindow = AfxGetMainWnd();
          HWND hSender = NULL;
          if (pMainWindow)
            hSender = pMainWindow->GetSafeHwnd();
 
          //Send the message to the previous instance. Use SendMessageTimeout instead of SendMessage to ensure we
          //do not hang if the previous instance itself is hung
          DWORD_PTR dwResult = 0;
          if (SendMessageTimeout(hWindow, WM_COPYDATA, reinterpret_cast<WPARAM>(hSender), reinterpret_cast<LPARAM>(&cds),
                                 SMTO_ABORTIFHUNG, dwTimeout, &dwResult) == 0)
          {
            //Previous instance is not responding to messages
            hWindow = NULL;
          }
 
          //Tidy up the heap memory we have used
          delete [] pszLocalCmdLine;
        }
 
        //Detach the CWnd we were using
        wndPrev.Detach();
      }
 
      //Unmap the MMF we were using
      UnmapViewOfFile(pInstanceData);
    }
 
    //Close the file handle now that we
    CloseHandle(hPrevInstance);
 
    //When we have activate the previous instance, we can release the lock
    ReleaseLock();
  }
 
  return hWindow;
}
 
void CInstanceChecker::QuitPreviousInstance(int nExitCode)
{
  //Try to open the previous instances MMF
  HANDLE hPrevInstance = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, GetMMFFilename());
    if (hPrevInstance)
    {
        // Open up the MMF
        int nMMFSize = sizeof(CWindowInstance);
        CWindowInstance* pInstanceData = static_cast<CWindowInstance*>(MapViewOfFile(hPrevInstance, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, nMMFSize));
        if (pInstanceData != NULL) //Opening the MMF should work
        {
          // Lock the data prior to reading from it
          CSingleLock dataLock(&m_instanceDataMutex, TRUE);
 
          //activate the old window
          ASSERT(pInstanceData->hMainWnd); //Something gone wrong with the MMF?
          HWND hWnd = pInstanceData->hMainWnd;
 
      //Ask it to exit
      HWND hChildWnd = GetLastActivePopup(hWnd);
      PostMessage(hChildWnd, WM_QUIT, nExitCode, 0);
      }
 
    //Close the file handle now that we
    CloseHandle(hPrevInstance);
  }
}

　　windows MFC下使用方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
在InitInstance()中添加:
//Check for the previous instance as soon as possible
  <strong>CInstanceChecker instanceChecker(_T("CInstanceChecker Example FrameWnd App"));</strong>
  <strong>instanceChecker.ActivateChecker();</strong>
 <strong> if (instanceChecker.PreviousInstanceRunning())</strong>
  {
    CCommandLineInfo cmdInfo;
    ParseCommandLine(cmdInfo);
 
      AfxMessageBox(_T("Previous version detected, will now restore it"), MB_OK);
   <strong> instanceChecker.ActivatePreviousInstance(cmdInfo.m_strFileName);</strong>
      return FALSE;
  }
 
...
 
  //Standard MFC stuff, create the mainframe
  CFrameWnd* pMainFrm = new CMyFrameWnd();
  if (!pMainFrm->Create(NULL, m_pszAppName))
    return FALSE;
  pMainFrm->ShowWindow(SW_SHOW);
  m_pMainWnd = pMainFrm;
 
  // If this is the first instance of our App then track it so any other instances can find us
  <strong>instanceChecker.TrackFirstInstanceRunning();
 
 
     
</strong>

　　如需实现像Notepad++追加在程序后面的效果,可在CFrameWnd中添加:

添加WM_COPYDATA消息响应

1
2
3
4
5
6
7
8
9
10
11
12
LRESULT CMyFrameWnd::OnCopyData(WPARAM /*wParam*/, LPARAM lParam)
{
  COPYDATASTRUCT* pCDS = reinterpret_cast<COPYDATASTRUCT*>(lParam);
  TCHAR* pszCmdLine = static_cast<TCHAR*>(pCDS->lpData);
  if (pszCmdLine)
  {
    CString sMsg;
    sMsg.Format(_T("Another instance passed us the command line: %s"), pszCmdLine);
    AfxMessageBox(sMsg);
  }
  return TRUE;
}

0 0