将数据从 python 传输到 Windows 中的另一个应用程序的最佳方法是什么？

Question

我正在与 .Net (C++) 团队一起开发一个应用程序，并提供一个 COM 接口来与 python 和其他语言交互。

我们发现通过 COM 推送数据的速度非常慢。

我考虑了几种替代方案：

• 将数据转储到文件并通过
• mmap?
• 直接通过套接字传输数据？

根据您的经验，传递数据的最佳方式是什么？

Answer 1

在 Windows 进程间通信机制中，我们使用 Windows 命名管道获得了积极的经验。
使用 Windows 重叠 IO 和 pywin32 中的 win32pipe 模块。

您可以在Win32 上的Python 编程一书中了解有关win32 和python 的更多信息。

发送部分只需写入r'\\.\pipe\mypipe'。

侦听器 (ovpipe) 对象保存一个事件句柄，等待可能包含其他事件的消息涉及调用 win32event.WaitForMultipleObjects。

rc = win32event.WaitForMultipleObjects(
    eventlist,    # Objects to wait for.
    0,            # Wait for one object
    timeout)      # timeout in milli-seconds.

这是 python 重叠侦听器类的一部分：

import win32event
import pywintypes
import win32file
import win32pipe

class ovpipe:
"Overlapped I/O named pipe class"
def __init__(self):
    self.over=pywintypes.OVERLAPPED()
    evt=win32event.CreateEvent(None,1,0,None)
    self.over.hEvent=evt
    self.pname='mypipe'
    self.hpipe = win32pipe.CreateNamedPipe(
        r'\\.\pipe\mypipe',             # pipe name 
        win32pipe.PIPE_ACCESS_DUPLEX|   # read/write access
        win32file.FILE_FLAG_OVERLAPPED,
        win32pipe.PIPE_TYPE_MESSAGE|    # message-type pipe 
        win32pipe.PIPE_WAIT,            # blocking mode 
        1,                              # number of instances 
        512,                            # output buffer size 
        512,                            # input buffer size 
        2000,                           # client time-out
        None)                           # no security attributes
    self.buffer = win32file.AllocateReadBuffer(512)
    self.state='noconnected'
    self.chstate()

def execmsg(self):
    "Translate the received message"
    pass

def chstate(self):
    "Change the state of the pipe depending on current state"
    if self.state=='noconnected':
        win32pipe.ConnectNamedPipe(self.hpipe,self.over)
        self.state='connectwait'
        return -6

    elif self.state=='connectwait':
        j,self.strbuf=win32file.ReadFile(self.hpipe,self.buffer,self.over)
        self.state='readwait'
        return -6

    elif self.state=='readwait':
        size=win32file.GetOverlappedResult(self.hpipe,self.over,1)
        self.msg=self.strbuf[:size]
        ret=self.execmsg()
        self.state = 'noconnected'
        win32pipe.DisconnectNamedPipe(self.hpipe)
        return ret

Answer 2

XML/JSON 和 Web 服务或直接通过套接字。 它也是独立于语言和平台的，所以如果您决定要在 UNIX 上托管 python 部分，或者如果您想突然使用 Java 或 PHP 或几乎任何其他语言，您可以。

一般来说，像 COM 这样的专有协议/架构带来的限制多于其带来的好处。 这就是开放规范首先出现的原因。

华泰

Answer 3

在命名管道上+1，但我还想补充一点，从您的评论来看，您的应用程序似乎非常健谈。 每次进行远程调用时，无论底层传输有多快，整理数据和建立连接的成本都是固定的。 如果将 addpoint(lat, long) 方法更改为 addpoints(point_array) 方法，则可以节省大量开销。 这个想法类似于为什么我们有数据库连接池和http-keep-alive连接。 您实际拨打的电话越少越好。 如果您可以限制对现有 COM 解决方案的调用次数，那么您现有的 COM 解决方案甚至可能就足够好了。

Answer 4

升级 Python 上 gimel 的答案。
让它与事件一起工作确实很难。

import multiprocessing

import win32event
import pywintypes
import win32file
import win32pipe

import client


class ovpipe:
    "Overlapped I/O named pipe class"

    def __init__(self):
        self.over = pywintypes.OVERLAPPED()
        evt = win32event.CreateEvent(None, 1, 0, None)
        self.over.hEvent = evt
        self.pname = 'mypipe'
        self.hpipe = win32pipe.CreateNamedPipe(
            r'\\.\pipe\mypipe',  # pipe name
            win32pipe.PIPE_ACCESS_DUPLEX |  # read/write access
            win32file.FILE_FLAG_OVERLAPPED,
            win32pipe.PIPE_TYPE_MESSAGE |  # message-type pipe
            win32pipe.PIPE_WAIT,  # blocking mode
            2,  # number of instances
            512,  # output buffer size
            512,  # input buffer size
            2000,  # client time-out
            None)  # no security attributes
        self.buffer = win32file.AllocateReadBuffer(512)
        self.state = 'noconnected'
        self.chstate()

    def execmsg(self):
        "Translate the received message"
        return bytes(self.msg).decode()

    def chstate(self):
        "Change the state of the pipe depending on current state"
        if self.state == 'noconnected':
            win32pipe.ConnectNamedPipe(self.hpipe, self.over)
            self.state = 'connectwait'
            return -6

        elif self.state == 'connectwait':
            j, self.strbuf = win32file.ReadFile(self.hpipe, self.buffer, self.over)
            self.state = 'readwait'
            return -6

        elif self.state == 'readwait':
            size = win32file.GetOverlappedResult(self.hpipe, self.over, 1)
            self.msg = self.strbuf[:size]
            ret = self.execmsg()
            self.state = 'noconnected'
            win32file.WriteFile(self.hpipe, b'Hello, client!')
            win32pipe.DisconnectNamedPipe(self.hpipe)
            return ret


def client_main():
    PIPE_NAME = r'\\.\pipe\MyPipe'

    # open a named pipe for writing
    pipe = win32file.CreateFile(
        PIPE_NAME,
        win32file.GENERIC_READ | win32file.GENERIC_WRITE,
        0,  # no sharing
        None,  # default security attributes
        win32file.OPEN_EXISTING,
        0,  # default attributes
        None  # no template file
    )

    # send data to the server
    data = b'Hello, server!'
    win32file.WriteFile(pipe, data)
    print(f'Sent Message to Server: \"{data.decode()}\". Waiting for response')

    # receive a response from the server
    response = win32file.ReadFile(pipe, 65536)
    print(f'Received response from server: {response}')

    # close the named pipe
    win32file.CloseHandle(pipe)


def main():
    ov = ovpipe()
    rc = win32event.WaitForMultipleObjects(
        [ov.over.hEvent],  # Objects to wait for.
        0,  # Wait for one object
        500)  # timeout in milli-seconds.
    print(rc)
    p = multiprocessing.Process(target=client_main, daemon=True)
    p.start()
    for _ in range(5):
        rc = win32event.WaitForMultipleObjects(
            [ov.over.hEvent],  # Objects to wait for.
            0,  # Wait for one object
            2000)  # timeout in milli-seconds.
        print(rc)
        win32event.ResetEvent(ov.over.hEvent)
        if rc == 0:
            res = ov.chstate()
            if type(res) is str:
                print(f"Received message from client: {res}")
                break
    p.join(10000)


if __name__ == '__main__':
    main()

Answer 5

为每个替代方案设置测试并进行基准测试应该不会太复杂。 注意到击败上下文敏感的经验数据...:)

哦，如果你这样做，我相信很多人会对结果感兴趣。