Discussion :

[Gregory.M]

Bonjour,


Je voudrais quelque précision sur un article dans la FAQ.
Je veux donc tester si mon application est déja lancé.
le lien est la

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
static void Main()
{
    // En utilisant using, app.Dispose() est appelée automatiquement
    // Merci CSharp ;-)
    using (SingleInstanceApp app = new SingleInstanceApp("{123456789 - ABCD - EFEG - XXXX}"))
    {
        if (app.IsRunning())
            MessageBox.Show("Application déjà lancée");
        else
            Application.Run(new Form1());
 
    }
}

J'ai une question à propos de ce bout de code.
J'ai copié ce bout de code au lancement de mon application, et je peux encore lancer mon application plusieurs fois.

[tomlev]

C'est une appli WPF ?
Dans ce cas il faut faire autrement, car en WPF tu n'écris pas le Main toi-même, il est automatiquement généré à partir du fichier App.xaml. Le Main que tu as écrit n'est donc probablement jamais appelé...
La solution à mon avis consiste à prendre le mutex dans l'évènement Startup, et à le libérer dans l'évènement Exit :

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
    /// <summary>
    /// Interaction logic for App.xaml
    /// </summary>
    public partial class App : Application
    {
        private SingleInstanceApp _app = new SingleInstanceApp("{123456789 - ABCD - EFEG - XXXX}");
        private void Application_Startup(object sender, StartupEventArgs e)
        {
            if (_app.IsRunning())
            {
                MessageBox.Show("Application déjà lancée");
                Shutdown();
            }
        }
 
        private void Application_Exit(object sender, ExitEventArgs e)
        {
            if (_app != null)
                _app.Dispose();
        }
    }

[ikeas]

moi je faisais ca avec Process et je cherchait le nom de linstance de mon process pour voir si il etait deja lance
avec visual stuido en mopde debug ca risque de ne pas marcher
mais en reel ca focntionnait plutot bien ....

[tomlev]

moi je faisais ca avec Process et je cherchait le nom de linstance de mon process pour voir si il etait deja lance
avec visual stuido en mopde debug ca risque de ne pas marcher
mais en reel ca focntionnait plutot bien ....

oui, jusqu'au jour où tu tombes sur une autre appli dont l'exécutable a le même nom... la solution du mutex est quand même plus propre je trouve

[Gregory.M]

Merci pour les 2 soluions.
Je voudrais savoir ce qu'est un mutex et à quoi il sert?

Merci

C'est une appli WPF ?
Dans ce cas il faut faire autrement, car en WPF tu n'écris pas le Main toi-même, il est automatiquement généré à partir du fichier App.xaml. Le Main que tu as écrit n'est donc probablement jamais appelé...
La solution à mon avis consiste à prendre le mutex dans l'évènement Startup, et à le libérer dans l'évènement Exit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
 
/// <summary>
/// Interaction logic for App.xaml
/// </summary>
public partial class App : Application
{
   private SingleInstanceApp _app = new SingleInstanceApp("{123456789 - ABCD - EFEG - XXXX}");
  private void Application_Startup(object sender, StartupEventArgs e)
 {
     if (_app.IsRunning())
     {
         MessageBox.Show("Application déjà lancée");
         Shutdown();
     }
  }
 
  private void Application_Exit(object sender, ExitEventArgs e)
  {
      if (_app != null)
        _app.Dispose();
  }
}

Dois-je faire un appel de cette classe quelque part?

[ikeas]

je savais pas que les mutex etait partagé hors application
par contre moi j'ameliorerais le concept si tu veux bien
je metrait dans le mutex une information sur le nom et le numero de process
histoire de voir si l'appli est encore en cours (en cas de plantage par exemple)
tu vois le principe ?

je viens de tester ton exemple la ca marche pas ... sous wpf

cela dit y'a une exemple de single instance avec wpf
http://social.msdn.microsoft.com/For...-741633febf46/
qui utilise les IPC

ou la
http://msdn.microsoft.com/en-us/library/ms771662.aspx

[Gregory.M]

Cool merci

[Gregory.M]

C'est une appli WPF ?
Dans ce cas il faut faire autrement, car en WPF tu n'écris pas le Main toi-même, il est automatiquement généré à partir du fichier App.xaml. Le Main que tu as écrit n'est donc probablement jamais appelé...
La solution à mon avis consiste à prendre le mutex dans l'évènement Startup, et à le libérer dans l'évènement Exit :

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
    /// <summary>
    /// Interaction logic for App.xaml
    /// </summary>
    public partial class App : Application
    {
        private SingleInstanceApp _app = new SingleInstanceApp("{123456789 - ABCD - EFEG - XXXX}");
        private void Application_Startup(object sender, StartupEventArgs e)
        {
            if (_app.IsRunning())
            {
                MessageBox.Show("Application déjà lancée");
                Shutdown();
            }
        }
 
        private void Application_Exit(object sender, ExitEventArgs e)
        {
            if (_app != null)
                _app.Dispose();
        }
    }

Salut Tomlev,


Je viens d'essayer le code qui tu m'as donné.
J'ai le probleme suivant, en mode débugage il initialise bien mon object SingleInstanceApp mais par contre il ne passe jamais sur la méthode "Application Startup" ce qui fait que mon application peut se lancer plusieurs fois...

[Thomas Lebrun]

Dans le fichier App.xaml, tu t'es abonné à l'évent Startup ? Pour lui dire d'appeler la méthode Application_Startup ?

[ikeas]

be tom je parlais de ce code la

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
 public partial class App : Application
    {
        private SingleInstanceApp _app = new SingleInstanceApp("{123456789 - ABCD - EFEG - XXXX}");
        private void Application_Startup(object sender, StartupEventArgs e)
        {
            if (_app.IsRunning())
            {
                MessageBox.Show("Application déjà lancée");
                Shutdown();
            }
        }
 
        private void Application_Exit(object sender, ExitEventArgs e)
        {
            if (_app != null)
                _app.Dispose();
        }
    }

pour le reste du mutex je parlais du solution visant a inclure dans une classe contenant un mutex puisqu'il est selead ou derrivant de WaitHandle, les information du PID pour verrifier qu'il est mort ou vivant ...

[tomlev]

Greg.Diinote : vérifie que tu as quelque chose comme ça dans ton App.xaml :

Code XAML :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
<Application x:Class="TestPadWPF.App"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    StartupUri="Window1.xaml" Exit="Application_Exit" Startup="Application_Startup">
    <Application.Resources>
         
    </Application.Resources>
</Application>

pour le reste du mutex je parlais du solution visant a inclure dans une classe contenant un mutex puisqu'il est selead ou derrivant de WaitHandle, les information du PID pour verrifier qu'il est mort ou vivant ...

euh... j'ai rien compris
tu peux la refaire en français ?

[MABROUKI]

bonjour gregory,tu as avais demande comme lancer ton application comme single instance et tu avais demande si on peut utiliser "using et mutex"
voici l'astuce de bout de code qu'il faut ajouter à app.cs c'est une proc main shared :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Linq;
using System.Windows;
using System.Threading;
namespace WpfAppMutex
{
    /// <summary>
    /// Logique d'interaction pour App.xaml
    /// </summary>
 
    public partial class App : Application
 
    {
        private static bool isNew;
        [System.STAThreadAttribute()]
        public static void Main()
        {
            using (System.Threading.Mutex  m = new System.Threading.Mutex(true, "CeciEstUneValeurChaineQuiDoitEtreUnique", out isNew))
            {
                // si la valeur de retour isNew=true
                // le mutex a ete accorde par le systeme au -thread application-
                // avec le nom demande (chaine ) 
                if (isNew)
                {
                    WpfAppMutex.App app = new WpfAppMutex.App();
                    app.InitializeComponent();
                    app.Run();
                }
                // isNew=false
                // le mutex avec le nom specifie est deja attribue à un autre thread
                else
                {
 
                    MessageBox.Show("L'application WpfAppMutex est deja demarree", "WpfAppMutex", MessageBoxButton.OK, MessageBoxImage.Information, MessageBoxResult.OK);
                }
            }
        }
 
    }
}

ensuite tu navigue dans l'explorateur de solution ->app.xaml clic droit ->proprietes et dans action de generer tu le met à Page.
(sinon il te sort sub main existe deja).

inconvenient :
- ce genre de solution a un defaut,tu ne peux gerer les arguments de ligne de commande (application type MIDI ouvrant un document avec une extension perso et qui doit visualiser plusieurs doc a la fois avec un clic sur le fichier
,type Ms Word par exemple).
Il faut transmettre les arguments(nom de fichier) de Instance 2,instance 3
....etc à l'instance 1 deja demarre.
2 eme Solution -Official Site MSDN -pour cela Microsoft a bidouille une methode -de derniere minute - que voici :
- elle utilise une synchronization avec un WaiHandle

1/code a mettre dans app.xaml.cs

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Linq;
using System.Windows;
 
namespace WpfSingleInstanceByEventWaitHandle
{
	/// <summary>
	/// Interaction logic for App.xaml
	/// </summary>
	public partial class App : Application
	{
 
 
 
		protected override void OnStartup(StartupEventArgs e)
		{
            WpfSingleInstance.Make("WpfInstanceUniqueWaitHandle", this);
 
			base.OnStartup(e);
		}
 
	}
}

2/code de la classe manager WpfSingleInstance qui est appele par la classe app (rajout fichier WpfSingleInstance.cs) que tu dois ajouter à ton projet WPF:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
using System;
using System.Threading;
using System.Windows;
 
namespace WpfSingleInstanceByEventWaitHandle
{
    public static class WpfSingleInstance
    {
        internal static void Make(String name, Application app)
        {
            EventWaitHandle eventWaitHandle = null;
            String eventName = Environment.MachineName + "-" + Environment.CurrentDirectory.Replace('\\', '-') + "-" + name;
 
            bool isFirstInstance = false;
 
            try
            {
                eventWaitHandle = EventWaitHandle.OpenExisting(eventName);
            }
            catch
            {
                // it's first instance
                isFirstInstance = true;
            }
 
            if (isFirstInstance)
            {
                eventWaitHandle = new EventWaitHandle(
                    false,
                    EventResetMode.AutoReset,
                    eventName);
 
                ThreadPool.RegisterWaitForSingleObject( eventWaitHandle, waitOrTimerCallback, app, Timeout.Infinite, false);
 
                // not need more
                eventWaitHandle.Close();
            }
            else
            {
                eventWaitHandle.Set();
 
                // For that exit no interceptions
                Environment.Exit(0);
            }
        }
 
 
        private static void waitOrTimerCallback(Object state, Boolean timedOut)
        {
            Application app = (Application)state;
            app.Dispatcher.BeginInvoke(new activate(delegate() 
                { Application.Current.MainWindow.Activate();}),null);
        }
 
        private delegate void activate();
 
    }
}

3/ code exemple -xaml- pour la forme (code ordinaire)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
<Window x:Class="WpfSingleInstanceByEventWaitHandle.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Window1" Height="300" Width="300">
    <Grid Margin="10" VerticalAlignment="Center" HorizontalAlignment="Center">
 
		<RichTextBox BorderThickness="0">
			<FlowDocument>
 
			<Paragraph TextAlignment="Center"    FontWeight="bold">
					WpfSingleInstanceByEventWaitHandle
				</Paragraph>
 
				<Paragraph>
					WPF application Single Instance in one line of code
				</Paragraph>
 
			</FlowDocument>
		</RichTextBox>
 
    </Grid>
</Window>

4/ code behind de la forme(code ordinaire)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
 
namespace WpfSingleInstanceByEventWaitHandle
{
	/// <summary>
	/// Interaction logic for Window1.xaml
	/// </summary>
	public partial class Window1 : Window
	{
		public Window1()
		{
			InitializeComponent();
		}
	}
}

pour le build rien de special
bon code.......