Procédure récursive et sortie anticipée, problème ?

Version imprimable

Bonjour,

Voici le code de la procédure récursive :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
// copie du dossier
		private void CopyDir(string sourceDir, string destDir,int TID)
		{
			DirectoryInfo dir = new DirectoryInfo(sourceDir); if (dir.Exists)
			{
				try
				{
					string realDestDir;
					if (dir.Root.Name != dir.Name)
					{
						realDestDir = Path.Combine(destDir, dir.Name);
						if (!Directory.Exists(realDestDir))
							Directory.CreateDirectory(realDestDir);
					}
					else realDestDir = destDir;
					foreach (string d in Directory.GetDirectories(sourceDir))
					{
						// if ((new DirectoryInfo(d).Attributes & FileAttributes.System) != FileAttributes.System)
						if (!Tcontinue[TID]) break;
						CopyDir(d, realDestDir, TID);
					}
 
					if (!Tcontinue[TID]) return; 
					foreach (string file in Directory.GetFiles(sourceDir))
					{
						if (!Tcontinue[TID]) break;
						string fileNameDest = Path.Combine(realDestDir, Path.GetFileName(file));
						CopyFile(file, fileNameDest, TID);
					}
				}
				catch
				{
					// on stocke l'erreur
					if (errs[TID].Count < 50)
						errs[TID].Add(DateTime.Now.ToLongTimeString() + " : [" + appli_saved[TID] + "] Le répertoire \"" + sourceDir + "\" n'est plus accessible.");
					else
					{
						errs[TID].Add(DateTime.Now.ToLongTimeString() + " : [" + appli_saved[TID] + "] 50 erreurs sont apparues, arret de la sauvegarde " + appli_saved[TID]);
						Tcontinue[TID] = false;
						return;
					}
				}
			}
			else
				errs[TID].Add(DateTime.Now.ToLongTimeString() + " : [" + appli_saved[TID] + "] Le répertoire \"" + sourceDir + "\" est introuvable.");
		}

Mon programme copie via plusieurs threads des dossiers volumineux.
Aussi pour controler l'annulation de chaque thread, j'ai un tableau de boolean (Tcontinue[]) qui normalement devrait me permettre d'annuler en cours de copie un thread. Pour cela je souhaite controler dans la procédure "CopyDir" si la valeur contenue dans Tcontinue est true ou false, si false alors il faut sortir de la procédure et c'est à ce moment là que j'ai le problème, je n'arrive pas à sortir de la procédure, une idée ? Est-ce dû à la récursivité ?

Ps : TID est l'identifiant du thread en cours.

Merci

14/12/2009, 22h23
bacelar

"volatile" est ton ami :mrgreen:
http://msdn.microsoft.com/fr-fr/libr...w7(VS.80).aspx
15/12/2009, 15h15
Shypster

Non l'ajout du mot clé "volatile" n'a aucun effet.
J'ai l'impression que je ne peux pas sortir prématurément de ma boucle "foreach", il relance la procédure pour le dossier suivant.

Je ne comprends pas.
16/12/2009, 00h04
bacelar

Vous utilisez à de multiples endroits dans la même méthode une expression.
Sans le mot clé volatile, le compilateur est en droit de factoriser cette formule car rien n'indique qu'il ne peut pas le faire (volatile sert à cela).

Si l'expression n'est évaluée qu'une fois, vous êtes marron, car les modifications faites par les autres threads seront invisibles.

Commencez par le volatile et on verra après.
16/12/2009, 11h08
Shypster
J'ai ajouté à la variable "Tcontinue" le mot clé "volatile" :

Déclaration faite dans le thread principal.
Code:

1 2 Private volatile bool[] Tcontinue;
Quand je fais du pas à pas et que je n'exécute qu'un seul thread supplémentaire, le tableau en index 0 contient bien la valeur que je donne.

Quand je fais mon return dans la méthode "CopyDir" cela me renvoie systématiquement dans mon foreach et ainsi rappelle la méthode.

Je suis perdu là.
16/12/2009, 14h48
olibara

Citation:

Mon programme copie via plusieurs threads des dossiers volumineux

A mon avis c'est de toute facon une mauvaise idée 8O

Car deux copies simultanées faisant intervenir au moins un disque physique commun a de TRES forte chances d'etre plus lente que deux copies asynchrone

Donc a mon avis un seul thread gerant les copies est largement sufisant
Et personnelement.... la récursivité quand il faut il faut (mais c'est rare) si je peux m'en passer je l'evite, c'est souvent plus performant et plus lisible !
17/12/2009, 11h44
Shypster

Qu'appelles-tu copies asynchrones ?
Comment puis-je éviter la récursivité pour copier tout le contenu d'un dossier ?
17/12/2009, 12h04
olibara

Citation:

Qu'appelles-tu copies asynchrones ?

Oups j'ai voulu dire synchrone 8O !!
(je melange chaque fois les appellations)

Tu demare un process quand l'autre est terminé

Citation:

Comment puis-je éviter la récursivité pour copier tout le contenu d'un dossier ?

Une methode recursive est une methode se réappelle elle meme

On peut généralement remplacer un processus recursif par une boucle et un controle itératif !

J'admet que le parcours d'un arbre est le terrain privilégié pour une fonction recursive
Mais personnellement je prefere le traiter en boucle !

J'avoue aussi ne pas avoir bien lu ton code car quand quand je vois ce type d'indentation j'ai les yeux qui piquent 8O ;) !