Preface

The last time , We go through 《 quote Microsoft.VisualBasic Solve the problem of too many programs 》.

Although it is very simple , But only for WinForm Applications , And you need to refer to less commonly used Microsoft.VisualBasic Class library .

therefore , We decided to dig deep , See how it is implemented .

principle

By looking at WindowsFormsApplicationBase Of Run Method realization （ Code has been cut ）：

Public Sub Run(commandLine As String())
    If Not IsSingleInstance Then
        DoApplicationModel()
    Else
        ' This is a Single-Instance application
        Dim pipeServer As NamedPipeServerStream = Nothing
        If TryCreatePipeServer(ApplicationInstanceID, pipeServer) Then
            ' --- This is the first instance of a single-instance application to run.
            Using pipeServer
                WaitForClientConnectionsAsync(pipeServer, AddressOf OnStartupNextInstanceMarshallingAdaptor, cancellationToken:=tokenSource.Token)

                DoApplicationModel()
            End Using
        Else
            Dim awaitable = SendSecondInstanceArgsAsync(ApplicationInstanceID, commandLine, cancellationToken:=tokenSource.Token).ConfigureAwait(False)
            awaitable.GetAwaiter().GetResult()
        End If
    End If 'Single-Instance application
End Sub

The whole process can be analyzed as follows ：

1. Create a NamedPipeServerStream example

2. If created successfully , Then use WaitForClientConnectionsAsync Waiting for the 2 Connect application instances

3. If the creation fails , Then use SendSecondInstanceArgsAsync Xiang di 1 Send data to application instances

NamedPipeServerStream

Use NamedPipeServerStream Class can create named pipes .

Named pipes provide interprocess communication between a pipeline server and one or more pipeline clients . Named pipes can be unidirectional , It can also be two-way . They support message based communication , It also allows multiple clients to connect to the server process at the same time with the same pipe name .

Detailed instructions , Please refer to the official documentation 《 Use named pipes for network interprocess communication 》^[1]

Realization

Let's use the console program to demonstrate ：

const string pipeName = "MyIO";
const PipeOptions NamedPipeOptions = PipeOptions.Asynchronous | PipeOptions.CurrentUserOnly;

static async Task Main(string[] args)
{
    try
    {
        using (var pipeServer = new NamedPipeServerStream(
                pipeName: pipeName,
                direction: PipeDirection.In,
                maxNumberOfServerInstances: 1,
                transmissionMode: PipeTransmissionMode.Byte,
                options: NamedPipeOptions))
        {
            WaitForClientConnectionsAsync(pipeServer,str => Console.WriteLine(str));

            Console.WriteLine($"start server {args[0]}");
            Console.ReadKey();
        }
    }
    catch
    {
        await SendSecondInstanceArgsAsync(()=> $"call from {args[0]}").ConfigureAwait(false);
    }
}

It should be noted that ,WaitForClientConnectionsAsync Cannot add await, Otherwise, subsequent code cannot be executed .

WaitForClientConnectionsAsync

The implementation code is as follows ：

private static async Task WaitForClientConnectionsAsync(NamedPipeServerStream pipeServer, Action<string> callback)
{
    CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
    while (true)
    {
        await pipeServer.WaitForConnectionAsync(cancellationTokenSource.Token).ConfigureAwait(false);

        try
        {
            const int bufferLength = 1024;
            var buffer = new byte[bufferLength];
            using (var stream = new MemoryStream())
            {
                while (true)
                {
                    var bytesRead = await pipeServer.ReadAsync(buffer.AsMemory(0, bufferLength), cancellationTokenSource.Token).ConfigureAwait(false);
                    if (bytesRead == 0)
                    {
                        break;
                    }
                    stream.Write(buffer, 0, bytesRead);
                }

                stream.Seek(0, SeekOrigin.Begin);

                callback(Encoding.UTF8.GetString(stream.ToArray()));
            }
        }
        finally
        {
            pipeServer.Disconnect();
        }
    }
}

• Loop waiting for client connection

• Read the data sent by the client , Convert to string

• call callback Processing strings , Here is str => Console.WriteLine(str)

• Disconnect the client

SendSecondInstanceArgsAsync

The implementation code is as follows ：

private static async Task SendSecondInstanceArgsAsync(Func<string> func)
{
    using (var pipeClient = new NamedPipeClientStream(
        serverName: ".",
        pipeName: pipeName,
        direction: PipeDirection.Out,
        options: NamedPipeOptions))
    {
        CancellationTokenSource cancellationTokenSource2 = new CancellationTokenSource();
        cancellationTokenSource2.CancelAfter(2500);

        await pipeClient.ConnectAsync(cancellationTokenSource2.Token).ConfigureAwait(false);

        await pipeClient.WriteAsync(Encoding.UTF8.GetBytes(func()), cancellationTokenSource2.Token).ConfigureAwait(false);
    }
}

• Create client connection local pipeline service

• Send to server func Data generated ,, Here is ()=> $"call from {args[0]}"

Demo

Create multiple scripts ：

start " " "ConsoleApp1.exe" firstInstance

start " " "ConsoleApp1.exe" secondInstance

start " " "ConsoleApp1.exe" thirdInstance

After execution , We found that the program can only be opened once .

And received data from other multiple applications ：

Conclusion

Use NamedPipeServerStream relative The mutex Mutex The implementation of is complex .

But because you can communicate , Therefore, more flexible control can be achieved .

such as , The application regularly starts another instance of itself to download updates , After downloading, notify the current application and prompt the user whether to update .

Want to know more about , Please pay attention to my official account ”My IO“

Reference material

[1]

《 Use named pipes for network interprocess communication 》: https://docs.microsoft.com/zh-cn/dotnet/standard/io/how-to-use-named-pipes-for-network-interprocess-communication?WT.mc_id=DT-MVP-38491