Funktion A2 eine minute nach A1 aber Zeit nutzen.

[TomasH]

Hi,
Ich suche eine Möglichkeit um bei folgender Situation die Ressourcen (Zeit) besser zu nutzen.

Funktion A1 (initialisiert etwas)
Funktion A2 (darf frühestens 50 Sekunden nach A1 ausgeführt werden)
Funktion B1 (irgendwas)
Funktion B2 (irgendwas)

Im Prinzip will ich so ein kunstrukt:

....
	A1();
	B1();
	B2();
	while(Zeit_Seit_A1_Aufgerufen < 50 Sec)
	{
		wait();
	}
	A2();
...

Wie Baut man sich soetwas am besten?

PS: C# & .Net 4

[Ralf Jansen]

Thread.Sleep(50000);

anstatt der while Schleife.

Ist am einfachsten. Ob am besten hängt von mehr ab als du beschreibst.

[luker]

Umständlich, aber ohne den Hauptthread zu blockieren:

private void MethodOne
{
    A1();
    B1();
    B2();

    Timer timer = new Timer();
    timer.Interval = 50000;
    timer.Tick += new EventHandler(Timer_Tick);
    timer.Start();
}

private void Timer_Tick(object sender, EventArgs e)
{
    Timer timer = (Timer)sender;
    timer.Stop();
    timer.Dispose();

    A2();
}

[fanderlf]

Schau Dir mal die Task Parallel Library. Die kann auch Continuations (also Task ausführen nachdem ein anderer beendet wurde usw.).

http://msdn.microsoft.com/en-us/library/dd537609.aspx

[TomasH]

Thread.Sleep(50000);

anstatt der while Schleife.

Ist am einfachsten. Ob am besten hängt von mehr ab als du beschreibst.

Naja, das ist ja eben nicht sinnvoll. Will ja nur so kurz wie möglich warten.
Also wenn B1 und B2 schon 49 Sekunden gebraucht haben, ist es nicht sinnvoll ...

Umständlich, aber ohne den Hauptthread zu blockieren:

private void MethodOne
{
    A1();
    B1();
    B2();

    Timer timer = new Timer();
    timer.Interval = 50000;
    timer.Tick += new EventHandler(Timer_Tick);
    timer.Start();
}

private void Timer_Tick(object sender, EventArgs e)
{
    Timer timer = (Timer)sender;
    timer.Stop();
    timer.Dispose();

    A2();
}

Stimmt das Tatsächlich so?

Gehört das nicht im Main in einer Anderen reihnfolge?
Wie siht es da mit der Weiteren Ausführung aus.

Also

private void MethodOne
{
    A1();

    Timer timer = new Timer();
    timer.Interval = 50000;
    timer.Tick += new EventHandler(Timer_Tick);
    timer.Start();
	
    B1();
    B2();
	
	// hier sollte auf 50 Sekunden nach A1 gewartet werden
	// dann soll A2 ausgeführt werden.
}

private void Timer_Tick(object sender, EventArgs e)
{
    Timer timer = (Timer)sender;
    timer.Stop();
    timer.Dispose();

    A2();
}

Aber wie sieht es da nach B2 aus, wenn der Timer Nicht abgelaufen ist?
Dan ist Main ja schon aus ...
soll ja auch nihct sien.
Könnte man nach B2() noch eine art Wait-Schleife einbauen, die ein flag testet, das beim timer überlauf gesetzt wird?
Und dann wird A1 ausgeführt?

[Ralf Jansen]

Bevor wir da weiter raten und alle möglichen Vorschläge machen. Was ist das für eine Sorte von Project? Mit Messagepump (Winforms,WPF etc.) oder ohne(Console)?

Könnte man nach B2() noch eine art Wait-Schleife einbauen, die ein flag testet, das beim timer überlauf gesetzt wird?
Und dann wird A1 ausgeführt?

Du meinst A2. Natürlich. Wie genau hängt von obiger Frage ab.

[rolfrui]

für jede, in Intervalen zu startende Funktion, läßt sich eine System.Diagnostics.StopWatch als Zeitnehmer verwenden.

StopWatch watch = new StopWatch();

watch.Start();

while(true)
{

  System.Threading.Thread.Sleep(10);
   if(watch.ElapsedMilliseconds > 60000)
  {
     watch.Reset();
     ... mach was
      watch.start();
  }
  
   .. mach was anderes.

}

[TomasH]

Bevor wir da weiter raten und alle möglichen Vorschläge machen. Was ist das für eine Sorte von Project? Mit Messagepump (Winforms,WPF etc.) oder ohne(Console)?

Also ist eine GUI lose Anwendung, obwohl es auch mit einem GUI von einer anderen Anwendung interagiert, momentan ist kein Threading oder so eingebaut, und rennt, also fast prozedural durch ... Messagepump sagt mir gar nichts .

Aber der weitere Ablauf soll eben blockiert sein bis A2() auch abgearbeitet ist.

Du meinst A2. Natürlich. Wie genau hängt von obiger Frage ab.

Jop stimmt.

für jede, in Intervalen zu startende Funktion, läßt sich eine System.Diagnostics.StopWatch als Zeitnehmer verwenden.

Soll zwar nicht in intervallen laufen,
aber vl kann ich das ja adaptieren ....

[Ralf Jansen]

Windows ist ein Message bassiertes System deren Nachrichten eben durch eine Nachrichtenwarteschlange geroutet werden (die Messagepump). Zum Beispiel der hier empfohlene Timer (zumindest der normale) basiert auf solchen Nachrichten. Ein Consolenanwendung hat keine Messagepump, damit keine Nachrichtenverarbeitung und somit fällt dieser Timer flach.

Also entweder ein Lösung mit selber Zeitnehmen und in einer nach B1,B2 laufenden Schleife auf den Ablauf der 50 Sekunden testen (da hilft besagte StopWatch) oder gleich einen richtigen Thread abspalten und die Nebenläufigkeit ausprogrammieren.

[rolfrui]

Widerspruch

Das Problem besteht nur darin die Konsolenanwendung am Leben zu erhalten,
mit einer häßlichen while(true) Schleife ist das möglich.

class Program
    {
        static System.Timers.Timer tm = new System.Timers.Timer(1000d);
        static void Main(string[] args)
        {
            tm.Elapsed += new System.Timers.ElapsedEventHandler(tm_Elapsed);
            tm.Start();
            while (true)
            {
                System.Threading.Thread.Sleep(10);
            }
        }

        static void tm_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            Console.WriteLine(DateTime.Now.ToString());
        }
    }

[TomasH]

Also entweder ein Lösung mit selber Zeitnehmen und in einer nach B1,B2 laufenden Schleife auf den Ablauf der 50 Sekunden testen (da hilft besagte StopWatch) oder gleich einen richtigen Thread abspalten und die Nebenläufigkeit ausprogrammieren.

Threaden, weiß ich nicht wie sich das mim Rest verträgt (hate da mal die Anweisung das zu lassen, vl sind die gründe schon beseitigt).

Das Problem besteht nur darin die Konsolenanwendung am Leben zu erhalten,
mit einer häßlichen while(true) Schleife ist das möglich.

Wieso?

StopWatch watch = new StopWatch();

A1();
watch.Start();
B1();
B2();

do // hier wird gewartet
{
   Wait(1000);
} while (watch.ElapsedMilliseconds < 60000);

A2();

Scheint zu gehen.

[Ralf Jansen]

Wieso?

Weil sonst eventuell der Hauptthread zu Ende läuft und das Programm beendet wird bevor der parallele Thread oder Timer (der auch einen Thread benutzt) ausgeführt wurde. Ist aber natürlich nur nötig wenn Backgroundthreads (wie der im Beispiel verwendete Timer) beteiligt sind. Die Schleife muss natürlich auch nicht für die Ewigkeit ausgelegt sein.

Scheint zu gehen.

Wait entspricht Thread.Sleep?

Ich würde eher eine while Schleife nehmen. Mit do while wartest du auf Fall. Ist aber eventuell unnötig da B1, B2 schon länger als deine Wartezeit gebraucht haben und weiteres warten unnötig ist.