来自不同线程的Pythoncom PumpMessages

Question

我想做一些类似于要求这里的事情，但是使用像这里这样的threading。使用来自这里的答案，我的代码工作正常，只是没有识别ItemAdd事件(实际上，我认为是这样，而是在另一个线程中，这就是为什么没有输出)。

"""Handler class that watches for incoming mails"""
import ctypes # for the WM_QUIT to stop PumpMessage()
import logging
import win32com.client
import sys
import threading
import time
import pythoncom

# outlook config
CENTRAL_MAILBOX = "My Mailbox"

# get the outlook instance and inbox folders
outlook = win32com.client.Dispatch("Outlook.Application")
marshalled_otlk = pythoncom.CoMarshalInterThreadInterfaceInStream(
    pythoncom.IID_IDispatch, outlook)


class HandlerClass(object):

    def OnItemAdd(self, item):
        logger.info("New item added in central mailbox")
        if item.Class == 43:
            logger.info("The item is an email!")


class OtlkThread(threading.Thread):

    def __init__(self, marshalled_otlk, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.marshalled_otlk = marshalled_otlk
        self.logger = logging.getLogger("OLThread")

    def run(self):
        self.logger.info("Starting up Outlook watcher\n"
                         "To terminate the program, press 'Ctrl + C'")
        pythoncom.CoInitialize()
        outlook = win32com.client.Dispatch(
            pythoncom.CoGetInterfaceAndReleaseStream(
                self.marshalled_otlk,
                pythoncom.IID_IDispatch
            )
        )
        user = outlook.Session.CreateRecipient(CENTRAL_MAILBOX)
        central_inbox = outlook.Session.GetSharedDefaultFolder(user, 6).Items
        self.logger.info(f"{central_inbox.Count} messages in central inbox")

        win32com.client.DispatchWithEvents(central_inbox, HandlerClass)
        pythoncom.PumpMessages()
        pythoncom.CoUninitialize()  # this is prbly unnecessary as it will never be reached


def main():
    # pythoncom.CoInitialize()
    OtlkThread(marshalled_otlk, daemon=True).start()


if __name__ == "__main__":
    status = main()
    while True:
        try:
            # pythoncom.PumpWaitingMessages()
            time.sleep(1)
        except KeyboardInterrupt:
            logger.info("Terminating program..")
            ctypes.windll.user32.PostQuitMessage(0)
            sys.exit(status)

我尝试过各种方法，例如将sys.coinit_flags=0放在顶部，如建议的这里)，在主线程中调用PumpWaitingMessages()，以及将Outlook应用程序放在侧线程本身，而不是传递已封送的对象。这些都不起作用。

当我将PumpMessages放在主线程(相同的HandlerClass，但没有单独的线程)中时，它可以工作，电子邮件在到达时被识别，但是很明显，线程被阻塞了，甚至连KeyboardInterrupt异常都无法捕获。

那么，如何让outlook观察者在单独的线程中运行，以便将消息发送到主线程以供输出？

Answer 1

再次感谢你的回答，迈克尔，它引导我到这答案，其中也包含一个链接到一个优秀范例。答案和示例的主要优点是，与其将Outlook作为封送对象传递，不如将其作为客户端传递给处理程序。另外，使用WithEvents而不是DispatchWithEvents，并在导入pythoncom之前设置sys.coinit_flags = 0。

最终结果如下：

"""Handler class that watches for incoming mails"""
import ctypes # for the WM_QUIT to stop PumpMessage()
import logging
import sys
import time
from threading import Thread

sys.coinit_flags = 0  # pythoncom.COINIT_MULTITHREADED == 0
from pythoncom import (CoInitializeEx, CoUninitialize,
                       COINIT_MULTITHREADED, PumpWaitingMessages)
from win32com.client import Dispatch, WithEvents


# outlook config
CENTRAL_MAILBOX = "My Mailbox"


# COM event handler
class IncomingMailHandler:
    def OnItemAdd(self, item):
        logger.info("New item added in central mailbox")
        if item.Class == 43:
            logger.info(f"The item is an email with subject {item.Subject}")


# main thread
def main():
    # get the outlook instance and inbox folders
    outlook = Dispatch("Outlook.Application")
    user = outlook.Session.CreateRecipient(CENTRAL_MAILBOX)
    central_inbox = outlook.Session.GetSharedDefaultFolder(user, 6).Items
    logger.info(f"{central_inbox.Count} messages in central inbox")

    # launch the second thread
    thread = Thread(target=watcher, args=(central_inbox,), daemon=True)
    thread.start()


# other thread worker function
def watcher(client):
    logger = logging.getLogger("watcher")
    CoInitializeEx(COINIT_MULTITHREADED)
    WithEvents(client, IncomingMailHandler)
    # event loop 2
    _loop = 0
    while True:
        PumpWaitingMessages()
        _loop += 1
        if _loop % 20 == 0:
            logger.info("Watcher is running..")
        time.sleep(0.5)
    CoUninitialize()


if __name__ == "__main__":
    logger.info("Starting up Outlook watcher\n"
                "To terminate the program, press 'Ctrl + C'")
    status = main()
    while True:
        try:
            time.sleep(0.5)
        except KeyboardInterrupt:
            logger.info("Terminating program..")
            ctypes.windll.user32.PostQuitMessage(0)
            sys.exit(status)

Answer 2

格式良好的问题，有参考资料。谢谢。

答案。我使用threading.Thread(在这种情况下使用target= ....` )。但是，您也可以使用继承：

import logging
import threading
import time


def task(name):
    log = logging.getLogger('task-' + name)
    log.info("Starting up Outlook watcher\n"
                     "To terminate the program, press 'Ctrl + C'")
    while True:
        log.info("Doing work that takes time")
        time.sleep(1)


class OtlkThread(threading.Thread):

    def __init__(self, *args, **kwargs):
        self.log = logging.getLogger('task-class')
        super().__init__(*args, **kwargs)

    def run(self):
        self.log.info("Starting up Outlook watcher\n"
                 "To terminate the program, press 'Ctrl + C'")
        while True:
            self.log.info("Doing work that takes time")
            time.sleep(1)

def main():
    t1 = threading.Thread(target=task, args=('daemon',), daemon=True)
    t1.start()
    t2 = OtlkThread()
    t2.start()


if __name__ == "__main__":
    logging.basicConfig(level=logging.DEBUG,)

    main()
    while True:
        time.sleep(1)