Предотвращение “(Не отвечающий)” маркирует в окнах при обрабатывании большого количества данных в одной глыбе
os.PathLike реализует модель данных __subclasshook__ :
class PathLike(abc.ABC):
"""Abstract base class for implementing the file system path protocol."""
@abc.abstractmethod
def __fspath__(self):
"""Return the file system path representation of the object."""
raise NotImplementedError
@classmethod
def __subclasshook__(cls, subclass):
return hasattr(subclass, '__fspath__')
Это означает , что любой класс, реализующий __fspath__, будет считаться подклассом. [118 ]
>>> class Other:
... __fspath__ = None
...
>>> issubclass(Other, Path)
True
6 ответов
Я не думаю, что Windows API может помочь Вам здесь.
С другой стороны, как насчет того, чтобы показать диалоговое окно с индикатором выполнения и заставляют его работать в отдельном потоке?
Текст как "Эта операция может занять полчаса" на диалоговом окне, может быть соответствующим также.
Вы ничего не должны на самом деле делать с сообщениями от PeekMessage. Просто назовите PeekMessage, Вы ничего не должны даже удалить из очереди или обработать ее. Пока это называют каждые 5 секунд или так, это заставит окна думать, что процесс является все еще быстро реагирующим.
Альтернативная идея состоит в том, чтобы иметь отдельный процесс/поток, который появится в лотке уведомления и сообщит пользователю, что процесс является активным ожиданием внутренней операции для завершения. Вы будете видеть их в более поздних версиях Visual Studio, Studio управления SQL Server, и т.д.
Хорошо, во-первых я сообщение upvoted Frederick, потому что нравится или нет, второй поток является, вероятно, лучшим способом пойти.
Однако, если Вы действительно не хотите идти по этой дороге, Вы могли бы вручную накачать очередь сообщений в своем внутреннем цикле приложений. Что-то вроде этого;
int Refresh()
{
MSG msg;
if (PeekMessage (&msg, NULL, 0, 0,PM_NOREMOVE))
if ((msg.message == WM_QUIT)
||(msg.message == WM_CLOSE)
||(msg.message == WM_DESTROY)
||(msg.message == WM_NCDESTROY)
||(msg.message == WM_HSCROLL)
||(msg.message == WM_VSCROLL)
)
return(1);
if (PeekMessage (&msg, NULL, 0, 0,PM_REMOVE))
{
TranslateMessage (&msg);
DispatchMessage (&msg);
}
return(0);
}
Это - на самом деле часть кода, который я использовал до перезаписи чего-то подобного как отдельный поток. В основном я взглянул на очередь, отфильтровываю нежелательные сообщения и сообщение на остальных. Это работает до степени, но вызвало некоторые случайные противные побочные эффекты, следовательно переписывание.
Необходимо будет чередовать обработку с обработкой сообщений так или иначе. Если потоки вне рассмотрения, Вы могли бы хотеть посмотреть на разделение обработки в несколько фаз. Один способ сделать это должно сделать некоторую обработку, когда Вы сначала получаете пакет, затем добавляете сообщение к высказыванию приложения, "продолжают обрабатывать здесь". Когда приложение получает, "продолжают обрабатывать здесь" сообщение, оно сделает еще некоторую обработку, и или отправит, другой "продолжает обрабатывать здесь", обмениваются сообщениями или заканчиваются.
Существует несколько соображений хотя:
- Необходимо удостовериться, что состояние приложения последовательно каждый раз, когда Вы добавляете сообщение себе и подчиняетесь циклу сообщения, поскольку другая обработка сообщений могла бы произойти тем временем. Это может быть сделано, например, только изменив состояние в заключительной фазе обработки.
- Другой пакет мог бы прибыть при тихой обработке первого пакета. Если изменение порядка обработки было бы плохо для приложения, Вы могли обработать, это, например, регистрация "напоминают мне обработать этот пакет позже" сообщение, когда это происходит.
Я не знаю, было ли это выполнимо в рамках дизайна Вашего приложения, но это будет один способ решить проблему.
Если Вы разветвляетесь от потока, Вы, скорее всего, волнуетесь по поводу некоторого другого пользовательского случая действия, который может зависеть от результата длительной операции (да, параллелизм). Так подробно останавливающийся, что заявил Fredrick, если Вы действительно отделяете новый поток и поднимаете индикатор выполнения, Вы могли бы заблокировать фокус на индикатор выполнения, чтобы мешать пользователю взаимодействовать с остальной частью приложения. Этого должно быть достаточно для реализации действительно простого второго потока, действительно не имея необходимость волноваться о параллелизме, потому что Вы по существу блокируете остальную часть приложения путем отключения пользовательского взаимодействия.
Предположение, что это - обработка данных, которые поднимают все время а не получение (и Вы серьезно относитесь к предотвращению потока - который является прекрасным IMOHO) данных Вы могли:
- В функции, что Вы в настоящее время обрабатываете сообщение, создайте модальное диалоговое окно, которое показывает, "ожидайте" сообщение (или сделайте это скрытым, маленьким, безотносительно...). Копия (или отправляют указатель, и т.д....) данные Вы обрабатываете к членской переменной того диалогового окна.
- В модальном диалоговом окне добавляют пользовательское сообщение себе для обработки данных.
- В обработчике сообщений диалогового окна обработайте одну "единицу" работы. Отслеживайте, какова следующая "единица" работы. Добавьте то же сообщение снова.
- Повторите это постсообщение "цикл", пока не сделано. Закройте свое диалоговое окно.
Природа модального диалогового окна сохранит, Вы - "быстро реагирующее" приложение, с минимальным прерыванием или изменяетесь на то, как приложение работало ранее. Повторная входимость может быть проблемой с модальными циклами, особенно если какое-либо из этого связано с сообщением WM_PAINT. (кто-либо когда-нибудь утверждает внутренний код рисования? хорошие времена, хорошие времена...)
Диалоговое окно могло даже иметь кнопку отмены, если Вы хотели бы.