C#实现托盘程序并禁止多个应用实例运行的方法

我来为您详细讲解“C#实现托盘程序并禁止多个应用实例运行的方法”的完整攻略：

实现托盘程序

实现托盘程序需要使用到.Net Framework提供的NotifyIcon控件，下面是一个简单的示例代码：

private NotifyIcon notifyIcon; // 托盘图标

public Form1()
{
    InitializeComponent();
    notifyIcon = new NotifyIcon();
    notifyIcon.Text = "托盘程序";
    notifyIcon.Icon = new Icon("icon.ico");
    notifyIcon.Visible = true;
    notifyIcon.MouseClick += new MouseEventHandler(notifyIcon_MouseClick);
}

private void notifyIcon_MouseClick(object sender, MouseEventArgs e)
{
    if (e.Button == MouseButtons.Left)
    {
        // 左键单击托盘图标时的处理逻辑
    }
}

禁止多个应用实例运行

实现禁止多个应用实例运行可以使用Mutex类，下面是一个简单的示例代码：

private static Mutex mutex = null;

if (!mutex.WaitOne(TimeSpan.FromSeconds(3), false))
{
    MessageBox.Show("程序已经在运行中...");
    Application.Exit();
}
else
{
    Application.Run(new Form1());
}

以上代码中，通过创建一个命名为"MutexName"的Mutex对象，并使用WaitOne方法来判断是否已经有一个同名的应用程序正在运行。如果已经有另外一个实例在运行，则弹出提示窗口并退出应用程序，否则正常运行。

示例说明

示例1

以下代码实现了一个托盘程序，当右键点击托盘图标时，弹出“关于”窗口，当左键点击托盘图标时，弹出“退出”提示框并退出应用程序，实现了禁止多个实例同时运行。

using System;
using System.Drawing;
using System.Threading;
using System.Windows.Forms;

namespace TrayApp
{
    static class Program
    {
        private static Mutex mutex = null;

        [STAThread]
        static void Main()
        {
            bool createdNew;

            mutex = new Mutex(true, "TrayAppMutex", out createdNew);

            if (!createdNew)
            {
                MessageBox.Show("程序已经在运行中...");
                return;
            }

            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new Form1());
        }

        private class Form1 : Form
        {
            private NotifyIcon notifyIcon;
            private ContextMenu contextMenu;
            private MenuItem menuItemAbout;
            private MenuItem menuItemExit;

            public Form1()
            {
                notifyIcon = new NotifyIcon();
                contextMenu = new ContextMenu();
                menuItemAbout = new MenuItem();
                menuItemExit = new MenuItem();

                // 初始化控件
                notifyIcon.Icon = new Icon("icon.ico");
                notifyIcon.Visible = true;

                contextMenu.MenuItems.AddRange(new MenuItem[] {
                    menuItemAbout,
                    new MenuItem("-"), // 分割线
                    menuItemExit});

                menuItemAbout.Text = "关于";
                menuItemAbout.Click += new EventHandler(menuItemAbout_Click);

                menuItemExit.Text = "退出";
                menuItemExit.Click += new EventHandler(menuItemExit_Click);

                notifyIcon.ContextMenu = contextMenu;
            }

            private void menuItemAbout_Click(object sender, EventArgs e)
            {
                MessageBox.Show("这是一个托盘应用程序");
            }

            private void menuItemExit_Click(object sender, EventArgs e)
            {
                if (MessageBox.Show("确定要退出程序吗？", "提示", MessageBoxButtons.YesNo) == DialogResult.Yes)
                {
                    Application.Exit();
                }
            }

            protected override void OnFormClosing(FormClosingEventArgs e)
            {
                if (MessageBox.Show("确定要退出程序吗？", "提示", MessageBoxButtons.YesNo) == DialogResult.No)
                {
                    e.Cancel = true;
                }
            }
        }
    }
}

示例2

以下代码实现了禁止重复运行功能，通过命名管道通讯的方式与其他进程通讯来检测是否已经有另外一个进程在运行。

using System;
using System.IO;
using System.IO.Pipes;
using System.Threading;
using System.Windows.Forms;

namespace SingleInstanceApplication
{
    static class Program
    {
        private const string PipeName = "SingleInstanceNamedPipe";
        private static Mutex mutex = null;

        [STAThread]
        static void Main()
        {
            bool createdNew;
            mutex = new Mutex(true, "SingleInstanceMutex", out createdNew);

            if (!createdNew)
            {
                if (MessageBox.Show("已经有一个实例正在运行，要退出当前实例吗？", "提示", MessageBoxButtons.YesNo) == DialogResult.Yes)
                {
                    // 发送退出命令
                    using (var pipe = new NamedPipeClientStream(".", PipeName, PipeDirection.InOut))
                    {
                        pipe.Connect();
                        using (var sr = new StreamReader(pipe))
                        using (var sw = new StreamWriter(pipe))
                        {
                            sw.WriteLine("exit");
                            sw.Flush();
                            var response = sr.ReadLine();
                            if (response == "exit")
                            {
                                // 成功发送退出命令
                            }
                        }
                    }
                }
                return;
            }

            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new Form1(PipeName));
        }

        private class Form1 : Form
        {
            private string pipeName;

            public Form1(string pipeName)
            {
                this.pipeName = pipeName;

                // 初始化控件
                var label = new Label();
                label.Text = "这是一个单实例应用程序";
                label.Font = new Font("微软雅黑", 24, FontStyle.Bold);
                label.Dock = DockStyle.Fill;

                Controls.Add(label);

                // 监听命令管道
                ThreadPool.QueueUserWorkItem((o) =>
                {
                    using (var pipe = new NamedPipeServerStream(pipeName, PipeDirection.InOut))
                    {
                        pipe.WaitForConnection();
                        using (var sr = new StreamReader(pipe))
                        using (var sw = new StreamWriter(pipe))
                        {
                            while (true)
                            {
                                var command = sr.ReadLine();
                                if (command == "exit")
                                {
                                    sw.WriteLine("exit");
                                    sw.Flush();
                                    Application.Exit();
                                    break;
                                }
                            }
                        }
                    }
                });
            }
        }
    }
}

以上两个示例代码都是基于C#语言实现的，分别通过使用NotifyIcon控件和命名管道通讯的方式实现了托盘程序和禁止多个实例同时运行的功能，供您参考。