Gibt es da eine Möglichkeit dies zu realisieren?
Danke

Evtl. könnte man den Aufruf ja in einem Thread ausführen, und dieser läuft x Sekunden, wäre das möglich?

Evtl. könnte man den Aufruf ja in einem Thread ausführen, und dieser läuft x Sekunden, wäre das möglich?

Threads abbrechen ist eigentlich immer eine ganz schlechte Idee. Das Problem ist, dass du nicht weisst was der Thread, zu dem Zeitpunkt wo er abgebrochen wurde, gerade gemacht hat. Dadurch kannst du die die Konsistenz aller möglichen Datenstrukturen zerstören (nicht nur eigener, auch welche die vom OS oder eine externen Library verwaltet werden).

Bei sleep() ist doch so, dass der Aufruf dann pausieren würde und wenn er in dieser Zeit etwas empfangen sollte, würde er nichts mitbekommen?...?

Ich will halt erreichen, wenn nach der Zeit x keine Rückmeldung vom Server kommt, dass ich diesen Fehler behandeln kann.

Wenn die Library, die die Kommunikation mit dem Server implementiert, das nicht unterstützt, dann gibt es keinen wirklich schönen Weg das zu machen.

Und wenn sie es unterstützt, dann kannst/musst du die dafür vorgesehenen Funktionen/Einstellungen/... der Library verwenden.

Die einzige Möglichkeit, die mir sonst noch einfällt, ist die ganze Kommunikation in einen eigenen Thread auslagern, der den Hauptthread benachrichtigt wenn die Antwort angekommen ist.

Wenn sie nicht in der gewünschten Zeit ankommt, kannst du im Hauptthread weitermachen. Den Kommunikations-Thread musst du aber weiterlaufen lassen. Dabei musst du natürlich aufpassen, dass die Lebenszeit der ganzen beteiligten Objekte so geregelt ist, dass es auch nie passieren kann, dass etwas zu früh gelöscht wird bzw. gar nicht mehr gelöscht wird.

Also z.B. inetwa so:

shared_ptr<Result> DoStuffWithTimeout(shared_ptr<Request> const& request)
{
    shared_ptr<MyResultReceiverThing> resultReceiver(new MyResultReceiverThing());

    StartStuffThread(resultReceiver, request);

    if (resultReceiver.TimedWaitForResult(MyTimeout))
        return resultReceiver.GetResult();
    else
        throw MyException("blah");
}

void StartStuffThread(shared_ptr<MyResultReceiverThing> const& resultReceiver, shared_ptr<Request> const& request)
{
    // ...
}

void StuffThreadFunction(shared_ptr<MyResultReceiverThing> resultReceiver, shared_ptr<Request> request)
{
     try
     {
         MyConnection conn;
         conn.Connect(request.GetAddress());
         shared_ptr<Result> const result = conn.SendRequest(request);
         conn.Close();

         resultReceiver->SetResult(result);
     }
     catch (std::exception const& e)
     {
          resultReceiver->SetResult(ResultFromException(e));
     }
     catch (...)
     {
          resultReceiver->SetResult(ResultFromUnknownException());
     }
}

Das funktioniert OK, so lange conn.SendRequest() irgendwann mal selbst aufgibt, und das Timeout nicht zu hoch ist (verglichen mit der Frequenz der DoStuffWithTimeout() Aufrufe). Sonst kann es passieren, dass du so viele Threads erzeugst (die alle bloss rumhängen bis conn.SendRequest() endlich aufgibt), dass dem System die Resourcen ausgehen. Auf 32 Bit Windowsen ist z.B. typischerweise bei 2000 Threads schluss.