Discussion :

[lenoil]

Bonjour à tous,

j'ai réalisé un programme 'Console Application' qui cré un webrequest.
Ce web request interroge un web service par http et me renvoie des données.
Tout se passe bien sauf que le web service peut mettre plusieurs minutes pour répondre et me retourner
le résultat.

Il faut donc que je passe mon webrequest en asynchrone => ok je pense pouvoir y arriver
mais j'aimerais que dans la console dos un message s'affiche 'travail en cours' tous les deux secondes
pour montrer que cela travaille en attendant la réponse

Avez vous des idées ? Faut-il utiliser des threads ?
Avez vous des exemples de code ? des pistes ?

Merci pour vos réponses.

[Pol63]

un truc dans le genre ...

Code :

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

1
2
3
4
5
6
7
thread th = new thread(voidrequetehttp);
th.Start();
while (th.isalive) {
    Console.WriteLine("patientez");
    thread.sleep(2000);
}
Console.WriteLine("fini");

[lenoil]

merci beaucoup cela me parait pas mal .... j'y avait pas penser

J'essaye mais avant tout il faut que je fasse le reste.

[lenoil]

j'essaye de réaliser avec ton exemple ce que je veux faire mais je n'y arrive pas

de l'aide please

merci

[Pol63]

j'essaye de réaliser avec ton exemple ce que je veux faire mais je n'y arrive pas

de l'aide please

merci

avec autant de précisions ...

et puis ce n'est pas réellement un exemple que j'ai donné, je n'ai pas testé le code
je donne des pistes à creuser, si tu rencontres un problème tu l'expliques et éventuellement j'essaye du code plutot que de faire une estimation

[lenoil]

Oui je sais excuses moi

mais en fait j'ai apparemment réussi et j'ai même laissé en synchrone la webRequest

J'ai utilisé un timer et la fonction TimerEvent écrit un message d'attente

voici le code

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
aTimer = new System.Timers.Timer();
aTimer.Elapsed += new System.Timers.ElapsedEventHandler(TimerEvent);
aTimer.Interval = 250;
aTimer.Enabled = true;
 
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(strUrl);
            request.Timeout = Timeout.Infinite;
            request.Credentials = CredentialCache.DefaultCredentials;
            HttpWebResponse response = null;
            response = (HttpWebResponse)request.GetResponse();
 
etc....

A ton avis est ce bon ?

Merci

[Pol63]

je sais pas

à quoi sert le timer ?

[Arnard]

A faire le Console.WriteLine à priori. Ca parait un peu tiré par les cheveux, mais bon le rôle d'un timer est un peu pour ça, faire des actions récurrentes.

Par contre ce qui gêne est qu'il fasse son appel en synchrone, et du coup il perd tout intérêt dans le code ci bas. Il a inversé thread de traitement background et thread de notification !

[lenoil]

oui en fait je fait un console.writeline

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
static void TimerEvent(Object myObject, EventArgs myEventArgs)
    {
      if (bWorking == true) WriteMessage();
      else
      {
        Console.WriteLine("Traitement terminé");
        aTimer.Stop();
        aTimer.Close();
        aTimer.Dispose();
      }
    }

Par contre, c'est vrai mon bWorking n'est jamais mis à false

Je vais récrire ça proprement avec du asynchrone pour webRequest
et dès que mon retour de request est ok je mets bWorking à false
et cela devrait fonctionner proprement

comment auriez vous fait ?

[lenoil]

dès que je mets en asynchrone cela ne fonctionne plus je sais pas pourquoi ...

[Pol63]

on ne voit pas tout ton code, donc on ne comprend pas ce que tu as fait

enfin soit tu démarres un thread et tu utilises le webrequest en synchrone
soit tu appelles le webrequest en asynchrone

dans les 2 cas il faut faire attendre, avec le thread tu as .isalive qui te dit si c'est fini ou pas, pour le webrequest asynchrone tu peux créer un booléen

[lenoil]

Voila donc tout le code qui fonctionne en synchrone mais bon on peut faire mieux avec des threads je pense mais je n'y arrive pas ...

j'ai mis en commentaire la partie asynchrone

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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
 
class Program
  {
    static System.Timers.Timer aTimer;
    static string strExtensionHtml = ".html";
    static string strExtensionLog = ".log";
    static string strFilePath = "";
    static string strFilePathHtml = "";
    static string strFilePathLog = "";
    static string strPathDir = "";
    static DateTime dtDeb;
    static bool bWorking = true;
 
    static void TimerEvent(Object myObject, EventArgs myEventArgs)
    {
      if (bWorking == true) WriteConcoleMessage("**** " + CSUtil.DateTimeHMSToStringFr(DateTime.Now) + " Travail en cours pour " + strFilePath + " ... merci de patienter **** ");
      else
      {
        WriteConcoleMessage("Traitement terminé");
        aTimer.Stop();
        aTimer.Close();
        aTimer.Dispose();
      }
    }
 
    static void WriteConcoleMessage(string pstrMessage)
    {
      Console.WriteLine(pstrMessage);
    }
 
 
   /*
    static void GetPage(string url)
    {
      HttpWebRequest req = (HttpWebRequest) WebRequest.Create(url);
	    // Création de l'objet état
	    RequestState rs = new RequestState();
	    //On ajoute la requete dans l'objet état pour pouvoir le récupérer dans la callback
	    rs.Request = req;
 
	    // Appel asynchrone
	    req.BeginGetResponse(new AsyncCallback(ResponseCallback), rs);
    }
 
    static void ResponseCallback(IAsyncResult ar)
    {
      //Récupération de l'objet etat 
      RequestState rs = (RequestState)ar.AsyncState;
      //Récupération de la requete web (object HttpWebRequest)
      HttpWebRequest req = rs.Request;
      //Récupération de la réponse Web	
      HttpWebResponse resp = (HttpWebResponse)req.EndGetResponse(ar);
 
      Stream responseStream = resp.GetResponseStream();
      StreamReader sr = new StreamReader(responseStream, Encoding.UTF8);
      
 
      responseStream.Close();
    }
 
    */
 
 
 
    static void Main(string[] args)
    {
      string strFilePathExe = System.Reflection.Assembly.GetExecutingAssembly().Location;
      strPathDir = Path.GetDirectoryName(strFilePathExe);
      string strFileNameLog = Path.GetFileNameWithoutExtension(strFilePathExe) + strExtensionLog;
      strFilePathLog = strPathDir + @"\" + strFileNameLog;
      CSLog.BeginLog(strFilePathLog, true);
 
      try
      {
        if ((args == null)|| (args.Length == 0))
        {
          CSLog.WriteLine("Argument incorrect ! Vous devez paramétrer en argument du programme le chemin d'un fichier  !");
        }
        else
        {
          strFilePath = args[0];
          if (File.Exists(strFilePath))
          {
            CSLog.WriteLine("Début du traitement pour le fichier : " + strFilePath);
            dtDeb = DateTime.Now;
 
            // Information sur le fichier
            strPathDir = Path.GetDirectoryName(strFilePath);
            string strFileNameHtml = Path.GetFileNameWithoutExtension(strFilePath) + strExtensionHtml;
            strFilePathHtml = strPathDir + @"\" + strFileNameHtml;
 
 
            string strFileContenu = File.ReadAllText(strFilePath);
            Hashtable htJson = (Hashtable)JSON.JsonDecode(strFileContenu);
            string strUrl = htJson["Url"].ToString();
 
            CSLog.WriteLine("Lancement url : " + strUrl);
 
            aTimer = new System.Timers.Timer();
            aTimer.Elapsed += new System.Timers.ElapsedEventHandler(TimerEvent);
            aTimer.Interval = 2500;
            aTimer.Enabled = true;
 
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(strUrl);
            request.Timeout = Timeout.Infinite;
            request.Credentials = CredentialCache.DefaultCredentials;
            HttpWebResponse response = null;
            response = (HttpWebResponse)request.GetResponse();
 
            CSLog.WriteLine("Response Content length  : " + response.ContentLength.ToString());
            CSLog.WriteLine("Response Content Type  : " + response.ContentType.ToString());
            CSLog.WriteLine("Response Content Encoding  : " + response.ContentEncoding.ToString());
            bWorking = false;
 
            Stream receiveStream = response.GetResponseStream();
            StreamReader readStream = new StreamReader(receiveStream, Encoding.UTF8);
            string strResponseHtml = readStream.ReadToEnd();
 
            strFileContenu = readStream.ReadToEnd();
            File.WriteAllText(strFilePathHtml, strResponseHtml, Encoding.UTF8);
            string strMessage = "Rapport du traitement dans le fichier : " + strFilePathHtml;
            WriteConcoleMessage(strMessage);
            CSLog.WriteLine(strMessage);
 
            DateTime dtFin = DateTime.Now;
            TimeSpan tsDuree = dtFin.Subtract(dtDeb);
            string strDuree = tsDuree.Hours + ":" + tsDuree.Minutes + ":" + tsDuree.Seconds;
            strMessage = "Durée du traitement : " + strDuree;
            strMessage = "Durée du traitement : " + strDuree;
            WriteConcoleMessage(strMessage);
            CSLog.WriteLine(strMessage);
            response.Close();
            readStream.Close();
 
          }
          else
          {
            CSLog.WriteLine("Fichier  suivant inexistant " + strFilePath);
          }
        }
 
      }
      catch(Exception ex){
        CSLog.WriteLine("*** ERREUR ***" +  ex.Source + "-" + ex.StackTrace + "-" + ex.Message);
      }
      finally{
        CSLog.EndLog();
 
      }
 
 
    }
  }
 
 
  // La classe RequestState est utilise pour transmettre l'objet HttpWebRequest 
  // a travers l'appel asynchrone
  public class RequestState
  {
    public HttpWebRequest Request;
 
    public RequestState()
    {
      Request = null;
    }
  }