C++ odpowiednik .NET's Task.Delay?

Question

Piszę składnik C++/CX, który ma być używany przez aplikacje sklepu Windows. Szukam sposobu, aby osiągnąć to, co Task.Delay (1000) robi w języku C#.

Answer 1

Można utworzyć zadanie współbieżności ::, odczekać 1000 jednostek czasu, a następnie wywołać metodę ".then" dla zadania. Zapewni to przynajmniej czas oczekiwania na 1000 jednostek czasu między czasem utworzenia zadania a czasem jego wykonania.

Answer 2

Stare pytanie, ale wciąż nieodebrane.

Można użyć

#include <chrono> 
#include <thread> 


std::this_thread::sleep_for(std::chrono::milliseconds(1000)); 

ten będzie musiał C++11, co nie powinno stanowić problemu przy użyciu C++/CX.

Answer 3

ja nie zamierzam twierdzić, że jest czarodziejem - Nadal jestem całkiem nowy, C++ i UWP/CX, ale co ja używam to:

public ref class MyClass sealed { 
public: 
    MyClass() 
    { 
     m_timer = ref new Windows::UI::Xaml::DispatcherTimer; 
     m_timer->Tick += ref new Windows::Foundation::EventHandler<Platform::Object^>(this, &MyClass::PostDelay); 
    } 
    void StartDelay() 
    { 
     m_timer->Interval.Duration = 200 * 10000;// 200ms expressed in 100s of nanoseconds 
     m_timer->Start(); 
    } 
    void PostDelay(Platform::Object^ sender, Platform::Object ^args) 
    { 
     m_timer->Stop(); 
     // Do some stuff after the delay 
    } 
private: 
    Windows::UI::Xaml::DispatcherTimer ^m_timer; 
} 

Główną zaletą. w stosunku do innych rozwiązań jest to, że:

1. to non-blocking
2. masz gwarantowane zostać wezwany na gwincie XAML UI

Answer 4

Po roku używania C++/CX mam ogólną i racjonalnie poprawną odpowiedź na to pytanie.

This link (z dokumentacji biblioteki równoległej Visual C++) zawiera fragment kodu dla funkcji zwanej complete_after(). Ta funkcja tworzy zadanie, które zakończy się po określonej liczbie milisekund. Następnie można zdefiniować zadanie kontynuacji który będzie wykonywał później:

void MyFunction() 
{ 
    // ... Do a first thing ... 

    concurrency::create_task(complete_after(1000), concurrency::task_continuation_context::use_current) 
    .then([]() { 
     // Do the next thing, on the same thread. 
    }); 
} 

albo jeszcze lepiej, jeśli używasz Visual C++ 's coroutines możliwości wystarczy wpisać:

concurrency::task<void> MyFunctionAsync() 
{ 
    // ... Do a first thing ... 

    co_await complete_after(1000); 
    // Do the next thing. 
    // Warning: if not on the UI thread (e.g., on a threadpool thread), this may resume on a different thread. 
}