Discussion :

[new_wave]

Bonjour,

Soit le code suivant (j'ai enlevé tous les using pour ne pas être pollué par leur lecture)qui permet d'appeler les méthodes asynchrones du ServiceLivre d'ajout et de recupération des livres ajoutés .

Mais méthode d'ajout des livres AjouterUnLivre (Livre livre) me renvoie cette erreur.

StatusCode: 500, ReasonPhrase: 'Internal Server Error', Version: 1.1, Content: System.Net.Http.StreamContent, Headers:
{X-SourceFiles: =?UTF-8?B?QzpcVXNlcnNcaGFyQDQzXERvY3VtZW50c1xlX2JpYmxpb3RoZXF1ZVxTZXJ2ZXVyQVBJXGFwaVxMaXZyZQ==?=
Cache-Control: private
Date: Tue, 02 Jan 2024 13:41:18 GMT
Server: Microsoft-IIS/10.0
X-AspNet-Version: 4.0.30319
X-Powered-By: ASP.NET
Content-Length: 11138
Content-Type: text/html; charset=utf-8
}}

J'ai regardé à quoi correspond l'erreur Internal Internal Server Error'(code 500) et j'apprends qu'il faut que je regarde dans le fichier appsettings.

Je ne comprends pas, d'autant plus que jusqu'à présent cette méthode d'ajout d'un livre fonctionnait!!

J'ai malencontreusement cliqué sur l'option "Detacher tout" après un debogage.Est ce que cela peut être la raison de cette erreur?

Merci beaucoup de bien vouloir m'aider à résoudre cette erreur.

Bien cordialement.

new_wave

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
 
 
namespace ConsommerAPI
{
    class Program
    {
 
 
        static void Main(string[] args)
        {
 
            try
            {
                var tache = test_livre();
                //on bloque le thread principal avec l'appel à la fonction Wait 
                tache.Wait();
 
              //on recupère le résultat d'exécution de la tâche asynchrone
                var result = tache.Result;
 
                Console.WriteLine(result == null ? "null" : result.ToString());
 
                Console.ReadKey();
 
            }//fin de try
 
            catch (Exception ex)
            {
                   Console.WriteLine("Une erreur s est produite" + ex.Message, ex.StackTrace); 
            }
 
 
        }//fin de Main
 
       public static async Task<Livre> test_livre()
        {
 
            //on crée un service
           ServiceLivre sl = new ServiceLivre();
 
            Livre livre_1 = new Livre()
            {
 
                Title = "Ne le dis à personne",
                ParutionDate = new DateTime(2002,01,01),
                rayon = new Rayon()
                {
                    Id_rayon = 3,
                    NomRayon = "roman historique",
 
                }, //fin de rayon
 
 
 
 
                auteur = new Auteur()
                {
                    Id_auteur = 1,
                    Name = "Coben",
                    Surname = "Harlan",
                    DateOfBirthday = new DateTime(1962,01,04)
 
                }//fin de auteur
 
            };//fin de Livre
 
 
 
 
 
        Livre livre_2 = new Livre()
        {
 
            Title = "Cartes sur table",
            ParutionDate = new DateTime(1936, 01, 01),
            rayon = new Rayon()
            {
                Id_rayon = 2,
                NomRayon = "roman policier",
 
            },//fin de rayon
 
            auteur = new Auteur()
            {
                Id_auteur = 1,
                Name = "Christie",
                Surname = "Agatha",
                DateOfBirthday = new DateTime(1890, 12, 09)
 
            }
 
        };//fin de Livre
 
 
 
            var t1 = await sl.AjouterUnLivre(livre_1);
 
 
            var t4 = await sl.AjouterUnLivre(livre_2);
 
 
            IEnumerable<Livre> t5 = await sl.recupLesLivresAsync();
 
            return (Livre)t5; 
 
 
 
        }//fin de méthode test_livre()*/
 
 
 
    }//fin de classe
 
}//fin de Namespace

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
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
 
 
 
namespace ConsommerAPI
{
    public class ServiceLivre
    {
 
        private const string urlAPI = "http://localhost:41782/api/Livre";
 
        /// <summary>
        /// fonction asynchrone d'ajout d'un livre
        /// </summary>
        /// <param name="livre"></param>
        /// <returns>le livre ajouté</returns>
        public async Task<Livre> AjouterUnLivre(Livre livre)
        {
            HttpResponseMessage objetReponse = null;
            try
            {
                HttpClient client = new HttpClient();
 
                //sérialization d'un auteur passé en paramètre au format JSON
                //la classe de base JsonMediaTypeFormatter gère la sérialisation et la désérialisation des objets fortement typés à l'aide de l'ObjectContent. 
                ObjectContent<Livre> content = new ObjectContent<Livre>(livre, new JsonMediaTypeFormatter());
 
                //la méthode PostAsync envoie une requête asynchrone POST vers le serveur d'API
                objetReponse = await client.PostAsync($"{urlAPI}", content);
 
                //si ce POST s'est bien effectué
                if (objetReponse.IsSuccessStatusCode)
                {
                    return livre;
                }//fin de if
                else if (objetReponse.StatusCode == System.Net.HttpStatusCode.NotFound)
                {
                    //l'instruction return null concerne une fonction  renvoyant un objet , l'instruction return concerne une fonction  ne renvoyant rien, c'est à dire avec le type de retour void
                    return null;
                }//fin de else 
 
            }//fin de try
            catch (Exception ex)
            {
                Console.WriteLine($"Un problème avec API : status = {objetReponse.StatusCode}");
                Console.WriteLine(ex.Message);
 
            }//fin de catch
            return null;
 
        }//fin de AjouterUnLivre
        /// <summary>
        /// fonction de récupération asynchrone de tous les livres
        /// </summary>
        /// <returns>une liste le livres de type IEnumerable<Livre></returns>
      public  async Task<IEnumerable<Livre>> recupLesLivresAsync()
        {
 
            HttpResponseMessage objetReponse = null;
            string stringContenu = null;
            IEnumerable<Livre> listLivre = null;
 
 
            try
            {
                //creation et initialisation d'un client HTTP
                HttpClient client = new HttpClient();
 
                //récupération de tous les livres (voir en détail)
                objetReponse = await client.GetAsync($"{urlAPI}Livre/");
 
                if (objetReponse.StatusCode == System.Net.HttpStatusCode.OK)
                {
 
                    //récupération sur le serveur de ce contenu
                    HttpContent objetContenu = objetReponse.Content;
 
                    //opération asynchrone de serialization en string du contenu recupéré 
                    stringContenu = await objetContenu.ReadAsStringAsync();
 
                    //désérialization du contenu de la variable stringContenu en type <IEnumerable<Livre>>
                    listLivre = JsonConvert.DeserializeObject<IEnumerable<Livre>>(stringContenu);
 
                    return listLivre;
 
                }//fin de if 
                 //si on n'a pas obtenu de réponse du serveur
                else if (objetReponse.StatusCode == System.Net.HttpStatusCode.NotFound)
                {
                    return null;
                }//fin de else if
            }//fin de try
            catch (Exception ex)
            {
 
                throw new Exception($"Un problème avec API : status = {objetReponse.StatusCode}, contenu : {stringContenu}");
            }//fin de catch
 
            return null;
 
        }//fin de recupLesLivresAsync
 
 
        /// <summary>
        /// recuperation d'un livre par son id
        /// </summary>
        /// <param name="id"></param>
        /// <returns> un objet de type Livre</returns>
        public async Task<Livre> recupLivreById(int id)
        {
            //création et initialisation d'un client HTTP
            HttpClient client = new HttpClient();
            HttpResponseMessage objetReponse = null;
            string stringContenu = null;
            Livre livre = null;
 
 
            try
            {
                //récupération d'un livre
                objetReponse = await client.GetAsync($"{urlAPI}Livre/{id}");
 
                //si cette recupération s'est bien effectuée
                if (objetReponse.StatusCode == System.Net.HttpStatusCode.OK)
                {
                    HttpContent objetContenu = objetReponse.Content;
 
                    //opération asynchrone de serialization en string du contenu recupéré 
                    stringContenu = await objetContenu.ReadAsStringAsync();
 
                    //deserialization du contenu de la variable stringContenu en type Auteur
                    livre = JsonConvert.DeserializeObject<Livre>(stringContenu);
 
                    return livre;
 
                }//fin de try
                else if (objetReponse.StatusCode == System.Net.HttpStatusCode.NotFound)
                {
                    return null;
                }//fin de else if
            }//fin de try 
            catch (Exception ex) //Modifier par du try catch 
            {
                Console.WriteLine($"Un problème avec API : status = {objetReponse.StatusCode}, contenu : {stringContenu}");
 
                Console.WriteLine(ex.StackTrace);
            }//fin de catch
            return null;
 
        }//fin de recupAuteurById
 
 
        public async Task<Livre> recupLivreByAuteur(Auteur auteur)
        {
            //création et initialisation d'un client HTTP
            HttpClient client = new HttpClient();
            HttpResponseMessage objetReponse = null;
            string stringContenu = null;
            Livre livre = null;
 
 
            try
            {
                //récupération d'un livre par auteur
                objetReponse = await client.GetAsync($"{urlAPI}Livre/{auteur}");
 
                //si cette recupération s'est bien effectuée
                if (objetReponse.StatusCode == System.Net.HttpStatusCode.OK)
                {
                    HttpContent objetContenu = objetReponse.Content;
 
                    //opération asynchrone de serialization en string du contenu recupéré 
                    stringContenu = await objetContenu.ReadAsStringAsync();
 
                    //deserialization du contenu de la variable stringContenu en type Auteur
                    livre = JsonConvert.DeserializeObject<Livre>(stringContenu);
 
                    return livre;
 
                }//fin de try
                else if (objetReponse.StatusCode == System.Net.HttpStatusCode.NotFound)
                {
                    return null;
                }//fin de else if
            }//fin de try 
            catch (Exception ex) //Modifier par du try catch 
            {
                Console.WriteLine($"Un problème avec API : status = {objetReponse.StatusCode}, contenu : {stringContenu}");
 
                Console.WriteLine(ex.StackTrace);
            }//fin de catch
            return null;
 
        }//fin de recuplivreByAuteur
 
 
        /// <summary>
        /// méthode du client http pour la mise à jour d'un client 
        /// </summary>
        /// <param name="livre"></param>
        /// <returns></returns>
 
        public async Task<Livre>Update(Livre livre)
        {
            //création et initialisation d'un client HTTP
            HttpClient client = new HttpClient();
 
            HttpResponseMessage objetReponse = null;
 
            try
            {
 
                //sérialization d'un auteur passé en paramètre au format JSON
                //la classe de base JsonMediaTypeFormatter gère la sérialisation et la désérialisation des objets fortement typés à l'aide de l'ObjectContent. 
                ObjectContent<Livre> content = new ObjectContent<Livre>(livre, new JsonMediaTypeFormatter());
 
                //la méthode PutAsync envoie une requête asynchrone PUT vers le serveur d'API pour la mise à jour d'un Auteur
                //d'où l'usage de await
                objetReponse = await client.PutAsync($"{urlAPI}Livre/", content);
 
                //si ce PUT s'est bien effectué
                if (objetReponse.IsSuccessStatusCode)
                {
                    return livre;
                }//fin de if
                else if (objetReponse.StatusCode == System.Net.HttpStatusCode.NotFound)
                {
                    //l'instruction return null concerne une fonction renvoyant un objet , l'instruction return concerne une fonction  ne renvoyant rien, c'est à dire avec le type de retour void
                    return null;
                }//fin de else 
 
            }//fin de try
            catch (Exception ex)
            {
                Console.WriteLine("Un problème avec API : status = {objetReponse.StatusCode}");
 
                Console.WriteLine(ex.Message);
 
            }//fin de catch
            return null;
 
 
        }//fin de Update
 
 
 
        public async Task<Livre> Delete(Livre livre)
        {
            //création et initialisation d'un client HTTP
            HttpClient client = new HttpClient();
 
            HttpResponseMessage objetReponse = null;
 
            try
            {
                //la méthode DeleteAsync envoie une requête asynchrone DELETE vers le serveur d'API
                objetReponse = await client.DeleteAsync($"{urlAPI}Livre/{livre}");
 
                //si ce DELETE s'est bien effectué
                if (objetReponse.IsSuccessStatusCode)
                {
                    return livre;
                }//fin de if
                //si l'auteur à supprimer n'existe pas en BDD
                else if (objetReponse.StatusCode == System.Net.HttpStatusCode.NotFound)
                {
                    Console.WriteLine("l'objet à supprimer n'existe pas en Base de données");
                    //l'instruction return null concerne une fonction renvoyant un objet , l'instruction return concerne une fonction  ne renvoyant rien, c'est à dire avec le type de retour void
                    return null;
                }//fin de else 
                 //dans tous les autres cas 
 
                else
                {
                    Console.WriteLine("Un problème avec API : status = {objetReponse.StatusCode}");
                    return null;
                }
 
            }//fin de try
 
            catch (Exception ex)
            {
                Console.WriteLine("Un problème avec API : status = {objetReponse.StatusCode}");
 
                Console.WriteLine(ex.Message);
 
            }//fin de catch
 
            return null;
 
 
        }//fin de Delete
    }//fin de classe
}//fin de namespace