minos5000
2008-08-21, 15:58:57
Hi,
ich bastel gerade an einer Anwendung die später auf einem Handy laufen soll und ich will mit den Ressourcen möglichst schonend umgehen.
Die Anwendung realisiert ein Observer Pattern bei dem in unregelmäßigen Abständen verschiedene Funktionen aufgerufen werden und wann immer eine dieser Funktionen aufgerufen wird, soll die, ich sag mal Hauptklasse der Anwendung, darüber informiert werden.
Bisher verwende ich einen Thread in einer Endlosschleife, der einfach vor sich hin läuft, damit die Anwendung nicht terminiert. Aber ich habe das dumpfe Gefühl, dass es auch effizienter gehen müsste, denn wenn die Anwendung im Hintergrund läuft verhält sich das Gerät träger als sonst.
Ich habe beim Googeln ein Beispiel gefunden, wo anscheinend jemand GC.KeepAlive() verwendet, um die Anwendung am terminieren zu hindern. Wäre das auch hier eine Option?
Hier mal der Code, der die Anwendung anstößt und sich um das warten kümmert. Die "Update" Methode wird vom observed Subject immer dann aufgerufen, wenn eine dessen Funktionen aufgerufen wurde.
static class Program
{
static void Main()
{
Engine engine = new Engine();
}
}
class Engine : Observer
{
private Logger logger;
private PositionProvider pp;
private Thread t;
private bool running;
public Engine()
{
SDResult result;
this.logger = new Logger();
pp = new PositionProvider(logger);
pp.Observer = this;
result = pp.Startup();
logger.log("Result: " + result.ToString());
running = true;
t = new Thread(HappyWaiting);
t.Start();
}
public void Update(String s)
{
logger.log("Update called");
logger.log(s);
if (s == "update")
{
logger.log("Latitude: " + pp.Latitude);
logger.log("Longitude: " + pp.Longitude);
}
if (s == "shutdown")
{
running = false;
logger.log("running = false");
}
}
private void HappyWaiting()
{
logger.log("HappyWaiting called");
while (running)
{
Thread.Sleep(1000);
}
}
}
vg
minos
ich bastel gerade an einer Anwendung die später auf einem Handy laufen soll und ich will mit den Ressourcen möglichst schonend umgehen.
Die Anwendung realisiert ein Observer Pattern bei dem in unregelmäßigen Abständen verschiedene Funktionen aufgerufen werden und wann immer eine dieser Funktionen aufgerufen wird, soll die, ich sag mal Hauptklasse der Anwendung, darüber informiert werden.
Bisher verwende ich einen Thread in einer Endlosschleife, der einfach vor sich hin läuft, damit die Anwendung nicht terminiert. Aber ich habe das dumpfe Gefühl, dass es auch effizienter gehen müsste, denn wenn die Anwendung im Hintergrund läuft verhält sich das Gerät träger als sonst.
Ich habe beim Googeln ein Beispiel gefunden, wo anscheinend jemand GC.KeepAlive() verwendet, um die Anwendung am terminieren zu hindern. Wäre das auch hier eine Option?
Hier mal der Code, der die Anwendung anstößt und sich um das warten kümmert. Die "Update" Methode wird vom observed Subject immer dann aufgerufen, wenn eine dessen Funktionen aufgerufen wurde.
static class Program
{
static void Main()
{
Engine engine = new Engine();
}
}
class Engine : Observer
{
private Logger logger;
private PositionProvider pp;
private Thread t;
private bool running;
public Engine()
{
SDResult result;
this.logger = new Logger();
pp = new PositionProvider(logger);
pp.Observer = this;
result = pp.Startup();
logger.log("Result: " + result.ToString());
running = true;
t = new Thread(HappyWaiting);
t.Start();
}
public void Update(String s)
{
logger.log("Update called");
logger.log(s);
if (s == "update")
{
logger.log("Latitude: " + pp.Latitude);
logger.log("Longitude: " + pp.Longitude);
}
if (s == "shutdown")
{
running = false;
logger.log("running = false");
}
}
private void HappyWaiting()
{
logger.log("HappyWaiting called");
while (running)
{
Thread.Sleep(1000);
}
}
}
vg
minos