Components

Aus GameBrowser - Wiki

Wechseln zu:Navigation, Suche

Inhaltsverzeichnis

1 BackgroundWorker
2 AsyncJob
3 Async Download
4 Cache

BackgroundWorker

Der backgroundWorker dient dazu eine bestimmte Aufgabe isoliert von anderen Operationen auszuführen, dazu wird ein Worker in den BackgroundWorkerPool gelegt. Der Pool kann eine gewisse Anzahl an Workern im Hintergrund arbeiten lassen, diese Anzahl kann entweder im CTor des Pools angegeben werden oder beträgt die Anzahl an HardwareThreads (zB CPU Kerne).

Sind alle WorkerThreads mit Aufgaben befüllt werden Worker dem WorkerThread zugwiesen der am wenigsten zu tun hat. der WorkerThread wird wenn möglich sich den nächsten Worker nehmen und bearbeiten sobald ein alter Worker abgeschlossen wurde.

Wird ein Worker behandelt so kann dieser nach Abschluss ein Event aufrufen, das OnFinished Event. Das Event bekommt dabei als Argument den Worker selbst geliefert. Der Worker wird nach Beendigung seiner Aufgabe bzw nach abarbeiten des Events gelöscht.

Der Worker kann im Event seinen Status abfragen der 3 Stati annehmen kann: Completed, Failed (wenn beim abarbeiten eine Exception geworfen wurde) oder Canceled (muss selbst gesetzt werden).

Wozu kann man es verwenden? Langwierige Aufgaben welche sich selbst erledigen können dürfen sich als Worker bezeichnen, darunter fallen zb Downloadaktionen.

Beispiel:

```
class DownloadJob
```
```
	: public BackgroundWorkerBase
```
```
{
```
```
public:
```

	DownloadJob(const std::string& as_Source, const std::string& as_Destination)

```
		: BackgroundWorkerBase()
```
```
		, mk_DownlodedFile_(NULL)
```
```
	{
```
```
	}
```
```
 
```
```
	virtual void Run()
```
```
	{
```

		mk_DownlodedFile_ = new File(ms_Source, ms_Destination);

```
 
```
```
		if (!mk_DownlodedFile_->Download())
```

			throw std::excption("Error while downloading file.");

```
	}
```
```
 
```

	k_File* get_DownloadedFile() const { return mk_DownlodedFile_; }

```
 
```
```
private:
```
```
	std::string ms_Source;
```
```
	std::string ms_Destination;
```
```
	File* mk_DownlodedFile_;
```
```
};
```
```
 
```

void OnDownloadFinished(BackgroundWorker ak_pJob)

```
{
```

	boost::shared_ptr<DownloadJob> lk_pJob = boost::shared_dynamic_cast<DownloadJob>(ak_pJob);

	if (lk_pJob != NULL && lk_pJob->get_Status() == r_JobState::Completed)

```
	{
```
```
		...
```
```
	}
```
```
}
```
```
 
```
```
 
```
```
 
```

BackgroundWorkerPool lk_DownloadWorkerPool(gi_MaxDownloads);

```
...
```
```
DownloadJob* lk_Job_ = NULL;
```

lk_Job_ = new DownloadJob("http://www.Mirror.de/File.dat", "./Downloads/File.dat");

lk_Job_->OnFinished = boost::bind<void>(OnDownloadFinished, _1);

lk_DownloadWorkerPool.QueueJob(lk_Job_);

Beachtet bitte das die Events in dem Thread abgearbeitet werden in dem auch der WorkerPool erstellt wurde. Abgearbeitet werden die Events auch nur dann wenn ein k_AsyncJobPool diese abholt (Im MainThread sollte sowieso einer arbeiten.).

AsyncJob

Das AsyncJobs System ist eine Art erweitertes nachrichtenSystem, jeder Job der in einen AsyncJobPool gelegt wird kann von diesem ausgeführt werden. Ausgeführt werden diese Jobs allerdings nicht unbedingt in dem Thread in dem sie erstellt werden sondern in dem Thread für den sie bestimmt wurden. Ohne Zusätze ist dies immer der HauptThread.

Da die Abarbeitung/Empfang der Nachrichten im Zielthread nicht ohne weiteres abläuft ist es nötig im Zielthread regelmässig folgendes aufzurufen:

AsyncJobPool::get_Instance().ProcessJobs();

Hiermit ist es nun möglich relativ gefahrlos Aktionen in einem Zielthread auszuführen ohne sich um umständliche Locking-Mechanismen zu kümmern (Zum Beispiel Können so Fortschrittsmeldungen an den GUI thread gesendet werden der somit einen Fortschrittsbalken aktualisiert.).

Beispiel:

```
class ProgressInfoJob
```
```
	: public AsyncJobBase
```
```
{
```
```
public:
```
```
	ProgressInfoJob(float af_Value)
```
```
		: mf_Value(af_Valuen)
```
```
	{
```
```
	}
```
```
 
```
```
	virtual void Process()
```
```
	{
```

		UpdateProgressBar(mf_Value, 0.0f, 100.0f);

```
	}
```
```
 
```
```
private:
```
```
	float mf_Value;
```
```
};
```
```
 
```
```
 
```
```
void ProgressThread()
```
```
{
```

   AsyncJobPool& lk_JobPool = AsyncJobPool::get_Instance();

```
   for (int i = 0; i <= 100; ++i)
```

	   lk_JobPool.QueueJob(new ProgressInfoJob(i / 100.0f));

```
}
```

Für Einfachere Funktionsaufrufe bietet sich der SimpleFunctionCallJob an:

SimpleFunctionCallJob(boost::function<void(void*)> ak_Function, void* mv_Data_ = NULL)

Async Download

void OnDownloadFinished(tk_BackgroundWorker ak_pJob)

```
{
```

	boost::shared_ptr<ToFileDownloader> lk_pJob = boost::shared_dynamic_cast<ToFileDownloader>(ak_pJob);

	if (lk_pJob != NULL && lk_pJob->get_Status() == JobState::Finished)

```
	{
```

		std::cout << "Download completed." << std::endl;

```
	}
```
```
	else
```

		std::cout << "Download failed or canceled." << std::endl;

```
}
```
```
 
```
```
 
```

void OnDownloadProgress(std::wstring as_Source, std::wstring as_Target, size_t ar_CurrentSize, size_t ar_FinaleSize)

```
{
```

	std::wcout << L"Download progress (" << as_Source << L"): " << ar_CurrentSize << L"/" << ar_FinaleSize << std::endl;

```
}
```
```
 
```
```
 
```
```
 
```

boost::shared_ptr<ToFileDownloader> lk_pJob;

lk_pJob = boost::shared_ptr<ToFileDownloader>(

	new ToFileDownloader(L"http://www.dras.biz/download/Ocean4k.avi", L"C:/Test.avi",

		boost::bind<void>(OnDownloadProgress, _1, _2, _3, _4))

```
	);
```

lk_pJob->OnFinished = boost::bind<void>(OnDownloadFinished, _1);

lk_DownloadWorkerPool.QueueJob(lk_pJob);

It is also possible to download a file to a memory/stringstream, for this use the class k_ToMemoryDownloader and call upon the finish event get_MemoryStream() to retrive the used target memory stream.

Cache

Creating the Cache class:

// creates the Cache in LocalApplicationData\MyCacheDirectory\

// and sets the max cache size to 50 MegaBytes

Cache lk_Cache(L"MyCacheDirectory", 50);

Updating the cache (removing old date and freeing disc space):

```
lk_Cache.CleanUp(
```

    true, // True to delete expired data

    true, // True to remove the oldest data when the cache disc space limit has been reached

    false // False to disallow the deletion of every cache entrie

```
  );
```

Adding a MemoryBlock or a simple k_Variant:

// adds MyVariant for an unlimited expiration time into the cache

lk_Cache.SetData(L"MyVariant", lk_MyVariant);

```
 
```

// Adds a Datablock with the given size into the cache, this entry should expire after 3 minutes.

lk_Cache.SetData(L"MyDatablock", lc_Buffer_, lul_BufferSizeInByte, 3 * 60);

Explicit removing data:

```
lk_Cache.DeleteData(L"MyVariant");
```

Retriving a cache entry:

// retrives a variant (use lk_Variant.IsEmpty() to check if the entry was found)

Variant lk_Variant = lk_Cache.GetData(L"MyVariant");

```
 
```
```
// retrives a datablock
```
```
char* lc_Data_;
```
```
unsigned long lul_DataSize;
```

bool lb_Success = lk_cache.TryGetData(L"MyDatablock", &lc_Data_, lil_DataSize);

Components

Aus GameBrowser - Wiki

Inhaltsverzeichnis

BackgroundWorker

AsyncJob

Async Download

Cache

Persönliche Werkzeuge

Namensräume

Varianten

Ansichten

Aktionen

Suche

Navigation

Media

Werkzeuge