Discussion :

[hanubis37]

Bonjour à tous,

J'ai fait un service web qui me permet de récupérer des fichiers sur un serveur.
Je récupère chaque fichier sans aucun problème.

Mais, j'aimerai savoir comment faire (si c'est possible) pour avoir un état d'avancement lors de la récupération d'un gros fichier ?
Pour l'instant je peux seulement indiquer que la récupération du fichier "monfichier.txt" est en cours.
J'aimerai savoir, par exemple, si j'ai déjà récupéré 27% du fichier en cours de transfert.

Avez-vous déjà rencontré cela ?

Merci d'avance.

[DotNetMatt]

Ca dépend comment est-ce que tu fais ton téléchargement. Il y a différentes possibilités, mais comme tu ne montres pas de code il est difficile de t'aiguiller...

D'une manière générale, tu peux t'abonner à l'évènement WebClient.DownloadProgressChanged. Lorsque cet évènement est levé, tu peux mettre à jour une ProgressBar par exemple.

Bien entendu, il faudra gérer tout cela dans un thread secondaire pour ne pas freezer ton UI. Si tu n'es pas familier avec la gestion des threads, tu peux passer par un BackgroundWorker.

[hanubis37]

Voici le code que j'utilise. Je connais le BackgroundWorker, je l'utilise très souvent.

Côté Service Web:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
public Byte[] GetDocument(string DocumentName)
{
	string strdocPath;
	strdocPath = @"C:\SUPERVISEUR\VERSION\" + DocumentName;
 
	FileStream objfilestream = new FileStream(strdocPath, FileMode.Open, FileAccess.Read);
	int len = (int)objfilestream.Length;
	Byte[] documentcontents = new Byte[len];
	objfilestream.Read(documentcontents, 0, len);
	objfilestream.Close();
 
	return documentcontents;
}

Côté client:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
private void BtnRecupLastMaj_Click(object sender, EventArgs e)
{
	RecupLastMaj();
}
 
private BackgroundWorker bwRecupLastMaj = null;
 
#region Thread : RecupLastMaj
 
private void RecupLastMaj()
{
	if(bwRecupLastMaj == null)
	{
		bwRecupLastMaj = new BackgroundWorker();
		bwRecupLastMaj.WorkerReportsProgress = true;
		bwRecupLastMaj.RunWorkerCompleted += BwRecupLastMajRunWorkerCompleted;
		bwRecupLastMaj.ProgressChanged += BwRecupLastMajProgressChanged;
		bwRecupLastMaj.DoWork += BwRecupLastMajDoWork;
 
		IsBusy = true;
		bwRecupLastMaj.RunWorkerAsync();
        }
}
 
private void BwRecupLastMajDoWork(object sender, DoWorkEventArgs e)
{
	e.Result = RecupLastMajFromServiceWeb("setup.exe");
}
 
private byte[] RecupLastMajFromServiceWeb(string docName)
{
	byte[] file = ServiceMiseAjour.GetDocument(docName);
	return file;
}
 
private void BwRecupLastMajProgressChanged(object sender, ProgressChangedEventArgs e)
{
}
 
private void BwRecupLastMajRunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
	if(e.Cancelled == true)
	{
		MessageBox.Show("La récupération du fichier a été annulée.");
	} else if(e.Error != null) // Traitement des exceptions
	{
		MessageBox.Show(e.Error.ToString());
	} else
	{
		SaveLastMaj(e.Result as Byte[]);
	}
 
	IsBusy = false;
	bwRecupLastMaj = null;
}
 
private void SaveLastMaj(Byte[] file)
{
	if(file == null)
	{
		MessageBox.Show("Récupération du fichier => ECHEC");
	} else
	{
		if(SaveDocument(file, "MySetup.exe"))
		{
			MessageBox.Show("sauvegarde du fichier => OK");
		} else
		{
			MessageBox.Show("sauvegarde du fichier => ECHEC");
		}
	}
}
 
#endregion Thread : RecupLastMaj

[DotNetMatt]

Merci pour avoir posté ton code, effectivement tu utilises déjà un BackgroundWorker ce qui est déjà un bon point

Voici un exemple qui pourra te mettre sur la voie : Background worker thread in ASP.NET.

L'idée, c'est de mettre un UpdatePanel, avec un Timer et un Label ou une ProgressBar à l'intérieur. Le Timer va permettre de rafraichir l'UpdatePanel régulièrement afin de mettre à jour l'état d'avancement.

Il faudra également inclure le bouton qui lance l'action de téléchargement dans cet UpdatePanel.

[hanubis37]

Je travail avec des WinForm et surtout en WPF. J'ai l'habitude d'afficher un "BusyIndicator" pour indiquer un traitement en cours.
Je pensais également au "Timer" pour indiquer, tous les X temps, dans le "BusyIndicator", l'état de la récupération du fichier en pourcentage.

Le problème est que je ne sais pas comment savoir si j'ai déjà récupéré 10% ou 80% du fichier en cours.

[DotNetMatt]

Il faut que tu modifies une propriété de ton BusyIndicator pour qu'il affiche une progress bar. Je n'ai pas le nom de cette propriété sous la main mais en cherchant sur Google tu devrais trouver. Si tu veux absolument garder ce mode d'affichage, alors il faudra que tu modifies le template pour y binder ton avancement à la place du message "Loading"...

Ensuite, si tu regardes le second lien que je t'ai envoyé plus haut (BackgroundWorker), et que tu regardes les points "III.2. Débuter le traitement" et "III.3. Visualiser l'état d'avancement", tu verras comment procéder.

Comme il est indiqué, c'est à toi de définir comment mesurer l'état d'avancement. Ici comme tu télécharges un fichier, il faudrait par exemple compter les bytes reçus. Tu peux le faire en te basant sur le principe de la méthode récursive Treatment montrée dans l'exemple au point "III.2".

[hanubis37]

Changer le Template, je sais faire, pas de souci.
Le problème c'est de compter les bytes reçus.

Ok pour faire une fonction récursive.

Il suffit que je sache, avant de télécharger le fichier, la taille totale du fichier à recevoir. Pour cela, pas de souci.
Mais, comment savoir combien j'ai reçu d'octet sachant que le thread bloque sur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

e.Result = RecupLastMajFromServiceWeb("setup.exe");

tant que je n'ai pas tout reçu ?

[DotNetMatt]

La fonction récursive est un exemple, tu peux aussi envisager d'autres moyens. En fait ça dépend surtout de ton "architecture". Là par exemple, ton thread reste bloqué sur l'appel à RecupLastMajFromServiceWeb() et ne bougera que lorsque le téléchargement sera terminé.

Une solution serait donc de voir pour faire en sorte que cette méthode te renvoie des paquets de bytes (chuncks). En gros au moment du téléchargement, tu récupères la taille totale (ex. 100 bytes). Arbitrairement tu vas décider de décomposer ça en paquets de 20 byte chacun, donc tu vas recevoir 5 paquets...

Grâce à la récursivité, à chaque appel de la méthode, tu pourras savoir combien est-ce que tu en as reçu. Dans ce cas, chaque paquet représentera un avancement de 20%.

[hanubis37]

Très bonne idée !!! je n'y avais pas pensé.

Je vais essayer.