如何在Electron应用与UWP（Gamebar）应用间实现数据传输与IPC？

完全可以通过进程间通信（IPC）绕开手动开启文件权限的问题，以下是几种Windows平台下可行的实现方案，均无需依赖文件系统权限：

一、Windows命名管道（Named Pipes） #

这是Windows原生的IPC机制，性能优异，适合传输大体积数据（如图片），且完全在内存中传输，无需读写本地文件。

Electron端实现（Node.js） #

const net = require('net');
const fs = require('fs');

// 准备要发送的数据
const jsonMeta = { name: "game-screenshot", timestamp: Date.now(), width: 1920, height: 1080 };
const imageBuffer = fs.readFileSync("./game-capture.png");

// 连接到命名管道（命名格式固定为\\.\pipe\<管道名>）
const pipeClient = net.connect("\\\\.\\pipe\\electron-uwp-gamebar-ipc", () => {
    // 先发送JSON元数据的长度（4字节无符号整数，小端序）
    const jsonStr = JSON.stringify(jsonMeta);
    const jsonLenBuffer = Buffer.alloc(4);
    jsonLenBuffer.writeUInt32LE(jsonStr.length, 0);
    pipeClient.write(jsonLenBuffer);
    
    // 发送JSON内容
    pipeClient.write(jsonStr);
    
    // 发送图片数据的长度
    const imageLenBuffer = Buffer.alloc(4);
    imageLenBuffer.writeUInt32LE(imageBuffer.length, 0);
    pipeClient.write(imageLenBuffer);
    
    // 发送图片二进制数据
    pipeClient.write(imageBuffer);
    
    pipeClient.end();
});

pipeClient.on("error", (err) => {
    console.error("管道连接失败:", err.message);
});

UWP端实现（C#） #

using Windows.System.Pipes;
using System.IO;
using System.Text;
using System.Text.Json;

async Task ListenNamedPipe()
{
    // 创建命名管道服务器
    using var pipeServer = new NamedPipeServerStream("electron-uwp-gamebar-ipc", PipeDirection.In);
    await pipeServer.WaitForConnectionAsync();

    // 读取JSON元数据长度
    byte[] jsonLenBytes = new byte[4];
    await pipeServer.ReadAsync(jsonLenBytes, 0, 4);
    int jsonLength = BitConverter.ToUInt32(jsonLenBytes, 0);

    // 读取JSON元数据内容
    byte[] jsonBytes = new byte[jsonLength];
    await pipeServer.ReadAsync(jsonBytes, 0, jsonLength);
    string jsonStr = Encoding.UTF8.GetString(jsonBytes);
    var metaData = JsonSerializer.Deserialize<CaptureMetaData>(jsonStr);

    // 读取图片数据长度
    byte[] imageLenBytes = new byte[4];
    await pipeServer.ReadAsync(imageLenBytes, 0, 4);
    int imageLength = BitConverter.ToUInt32(imageLenBytes, 0);

    // 读取图片二进制数据
    byte[] imageBytes = new byte[imageLength];
    await pipeServer.ReadAsync(imageBytes, 0, imageLength);

    // 处理数据：比如保存到UWP应用本地存储（无需额外权限）
    var storageFile = await ApplicationData.Current.LocalFolder.CreateFileAsync(
        $"{metaData.timestamp}.png", 
        CreationCollisionOption.ReplaceExisting
    );
    await FileIO.WriteBytesAsync(storageFile, imageBytes);

    pipeServer.Disconnect();
}

// 自定义元数据类
public class CaptureMetaData
{
    public string name { get; set; }
    public long timestamp { get; set; }
    public int width { get; set; }
    public int height { get; set; }
}

二、Windows剪贴板（Clipboard） #

适合传输小体量数据，实现成本极低，无需额外监听或连接逻辑。

Electron端实现 #

const { clipboard } = require('electron');
const fs = require('fs');

const jsonMeta = { name: "game-screenshot", timestamp: Date.now() };
const imageBuffer = fs.readFileSync("./game-capture.png");

// 用自定义MIME类型打包数据（用null字符分隔JSON和图片）
const combinedBuffer = Buffer.concat([
    Buffer.from(JSON.stringify(jsonMeta) + '\0'),
    imageBuffer
]);
clipboard.writeBuffer("application/electron-uwp-gamebar-data", combinedBuffer);

UWP端实现 #

using Windows.ApplicationModel.DataTransfer;
using System.IO;
using System.Text;
using System.Text.Json;

async Task ReadClipboardData()
{
    var dataPackage = Clipboard.GetContent();
    if (!dataPackage.Contains("application/electron-uwp-gamebar-data")) return;

    var stream = await dataPackage.GetDataAsync("application/electron-uwp-gamebar-data") as IRandomAccessStream;
    using var reader = new DataReader(stream.GetInputStreamAt(0));
    await reader.LoadAsync((uint)stream.Size);

    byte[] allBytes = new byte[stream.Size];
    reader.ReadBytes(allBytes);

    // 按null字符分割JSON和图片数据
    int nullSeparatorIndex = Array.IndexOf(allBytes, (byte)0);
    string jsonStr = Encoding.UTF8.GetString(allBytes, 0, nullSeparatorIndex);
    var metaData = JsonSerializer.Deserialize<CaptureMetaData>(jsonStr);

    byte[] imageBytes = allBytes.Skip(nullSeparatorIndex + 1).ToArray();
    // 处理图片数据
}

三、本地WebSocket通信 #

适合跨平台兼容场景，实现逻辑简单，但需注意端口占用问题。

Electron端实现 #

const WebSocket = require('ws');
const fs = require('fs');

const wss = new WebSocket.Server({ port: 8888 });

wss.on('connection', (ws) => {
    // 发送元数据
    ws.send(JSON.stringify({ type: "meta", data: { name: "game-screenshot", timestamp: Date.now() } }));
    
    // 发送图片二进制数据
    const imageBuffer = fs.readFileSync("./game-capture.png");
    ws.send(imageBuffer, { binary: true });

    ws.on('close', () => wss.close());
});

UWP端实现 #

using Windows.Networking.Sockets;
using System.IO;
using System.Text.Json;

async Task ConnectLocalWebSocket()
{
    using var socket = new MessageWebSocket();
    socket.Control.MessageType = SocketMessageType.Utf8;
    await socket.ConnectAsync(new Uri("ws://localhost:8888"));

    var reader = new DataReader(socket.InputStream);
    reader.InputStreamOptions = InputStreamOptions.Partial;

    CaptureMetaData metaData = null;
    byte[] imageBytes = null;

    while (true)
    {
        await reader.LoadAsync(1024);
        if (reader.UnconsumedBufferLength == 0) break;

        if (metaData == null)
        {
            // 读取元数据
            string jsonStr = reader.ReadString(reader.UnconsumedBufferLength);
            var message = JsonSerializer.Deserialize<WebSocketMessage>(jsonStr);
            if (message.Type == "meta")
            {
                metaData = JsonSerializer.Deserialize<CaptureMetaData>(message.Data.ToString());
                // 切换为二进制模式接收图片
                socket.Control.MessageType = SocketMessageType.Binary;
            }
        }
        else
        {
            // 读取图片二进制数据
            imageBytes = new byte[reader.UnconsumedBufferLength];
            reader.ReadBytes(imageBytes);
            break;
        }
    }

    // 处理数据
    socket.Close(1000, "传输完成");
}

public class WebSocketMessage
{
    public string Type { get; set; }
    public object Data { get; set; }
}

方案选择建议 #

• 优先选命名管道：Windows原生机制，性能最高，无端口冲突问题，适合大体积图片传输
• 剪贴板：适合小数据场景，实现最快，无需额外服务或监听
• WebSocket：适合需要跨平台兼容的场景，但需处理端口占用和连接异常

内容的提问来源于stack exchange，提问作者Austin