J'ai toujours pensé que la génération de pages statiques dynamiquement n'est pas facile à faire. Je l'ai regardé en ligne hier et j'étais étourdi. C'était en fait très simple. L'idée est probablement comme ça.
1: Créez un modèle de page HTML et utilisez une chaîne spéciale pour représenter les endroits que vous souhaitez afficher dynamiquement dans cette page (tels que $ htmlstrstr $);
2: Dans le programme, utilisez cette page HTML pour lire une variable de chaîne telle que STR;
3: Utilisez la méthode de remplacement de la chaîne pour remplacer les caractères spéciaux par ce que vous voulez dans la première étape;
4Save;
OK, si facile, j'ai écrit une classe comme celle-ci dans C # aujourd'hui pour gérer dynamiquement les pages HTML. Je pensais que je l'écrivais toujours en entier. Je viens d'entrer en contact avec .NET, donc j'espère donner des conseils.
Remarque: Les codes de cette catégorie ne sont pas tous originaux, certains codes se réfèrent aux codes des internautes!
Ce qui suit est le code de la classe de conversion
Code
1 utilisation du système;
2using System.Text;
3using System.Web;
4Using System.Configuration;
5using System.io;
6NAMESPACE SOLUCKY
7 {
8 / ** //// <résumé>
9 /// DESCRIPTION RÉSUMÉ D'ASPXTOHTML.
10 /// Remarque: En utilisant cette classe, vous pouvez configurer la classe de modèle dans le fichier web.config. Comme indiqué ci-dessous
11 / ** // * <AppSettings>
12 <add key = "templateFilePath" value = "htmlmoudel.htm" />
13 <ajouter key = "htmlfilepath" value = "new /"> </ddd>
14 <add key = "errlogpath" value = "aspxtohtml_log.txt"> </ddd>
15 </ppSettings> * /
16 / ** /// </summary>
17 classe publique AspxtoHTML
18 {
19 / ** /// <résumé>
20 /// le nombre de paramètres à remplacer dans le fichier de modèle
21 /// </summary>
22 private int _templateParamCount = 0;
23 / ** /// <résumé>
24 /// le chemin d'accès où se trouve le fichier de modèle
25 /// </summary>
26 String privé _TemplateFilePath = ConfigUrationsSettings.AppSettings ["TemplateFilePath"];
27 / ** /// <résumé>
28 /// le chemin stocké dans le fichier HTML converti
29 /// </summary>
30 chaîne privée _htmlFilePath = configUrationsTetings.AppSettings ["htmlFilePath"];
31
32 / ** //// <Summary>
33 /// Encodage de la page de modèle
34 /// </summary>
35 codage privé _TemplateHtmlCode = coding.getEncoding ("gb2312");
36
37 / ** /// <résumé>
38 /// Encodage de fichiers converti
39 /// </summary>
40 codage privé _code = coding.getEncoding ("gb2312");
41
42 / ** //// <Summary>
43 /// Nom de fichier HTML converti
44 /// </summary>
45 String privé _convertedFileName = "";
46 / ** //// <résumé>
47 /// Paramètres dans le fichier de modèle
48 /// </summary>
49 String privé [] _TemplateFileParameter;
50
51 / ** /// <résumé>
52 /// La valeur réelle du paramètre dans le fichier ASPX doit être remplacée par le fichier HTML
53 /// </summary>
54 String privé [] _aspxFileParameter;
55
56 String privé _ERRLOGPATH = ConfigUrationsTetings.AppSettings ["ErrLogPath"];
57
58 Attributs # Attributs de la région
59
60 / ** //// <Summary>
61 /// Le nombre de paramètres à remplacer dans le fichier de modèle
62 /// </summary>
63 public int templateParamcount
64 {
65 Get
66 {
67 REVOIR This._TemplateParAmCount;
68}
69 SET // Lors de l'allocation du nombre de paramètres, le tableau réel est alloué pour les paramètres du fichier de modèle et les valeurs réelles du fichier ASPX pour remplacer les valeurs réelles du fichier HTML.
70 {
71 if (valeur <0)
72 Jetez un nouvel argument enception ();
73
74 if (valeur> 0)
75 {
76 this._templateParamCount = valeur;
77 // Paramètres dans le fichier de modèle
78 _TemplateFileParameter = new String [Value];
79 // La valeur réelle du paramètre dans le fichier ASPX doit être remplacée par le fichier HTML
80 _aspxFileParameter = new String [Value];
81}
82 d'autre
83 this._templateParamCount = 0;
84}
85}
86
87 / ** //// <summary>
88 /// Le chemin d'accès où se trouve le fichier de modèle
89 ///
90 /// </summary>
91 Template de chaîne publique
92 {
93 get {return this._templateFilePath;}
94 set {this._templateFilePath = valeur;}
95}
96 / ** /// <résumé>
97 /// Le chemin stocké dans le fichier HTML converti
98 /// </summary>
99 String public htmlfilepath
100 {
101 get {return this._htmlfilepath;}
102 set {this._htmlFilePath = valeur;}
103}
104
105 / ** /// <résumé>
106 /// Encodage de fichiers de modèle HTML
107 /// </summary>
108 Template de codage publichtmlcode
109 {
110 get {return this._templatehtmlcode;}
111 set {this._templatehtmlcode = coding.getEncoding (value.toString ());}
112}
113 / ** /// <résumé>
114 /// Encodage
115 /// </summary>
116 Code d'encodage public
117 {
118 get {return this._code;}
119 set {this._code = coding.getEncoding (value.toString ());}
120}
121 / ** /// <Summary>
122 /// Le chemin du fichier d'erreur est situé
123 /// </summary>
124 Public String Errlogpath
125 {
126 get {
127 if (! (This._errlogpath == null)))
128 Renvoie ce._ERRLOGPATH;
129 d'autre
130 return "aspxtohtml_log.txt";
131}
132 set {this._errLogPath = valeur;}
133}
134
135
136 #endregion
137
138 opération # opération de région
139
140 / ** /// <résumé>
141 /// Obtenez le chemin du fichier relatif où se trouve le fichier HTML converti
142 /// par exemple: si htmlfilepath = "/ news /"
143 /// Le nom de fichier HTML converti est 2005050505.html
144 /// alors la valeur retournée est /News/200505050505.html
145 /// </summary>
146 /// <Remarks> Renvoie null si cette propriété est appelée avant la méthode startConvert appelée </ Remarks>
147 String public htmlfileVirtualPath
148 {
149 Get
150 {
151 if (! (This._convertedFileName == ""))
152 RETOURS this.htmlFilePath + this._convertedFileName;
153 d'autre
154 retour null;
155}
156}
157
158 / ** /// <résumé>
159 /// Valeur de paie pour le tableau des paramètres de page HTML
160 /// </summary>
161 /// <param name = "param"> </ param>
162 public void SettemplateFileParameter (String [] param)
163 {
164 Essayez
165 {
166 if (param.length == this.templateParAmCount)
167 this._templatefileParameter = param;
168 // else // Le nombre est différent de la définition d'origine
169 //
170}
171 Catch (System.Exception ex)
172 {
173 Writerrfile (ex);
174}
175}
176 / ** /// <Summary>
177 /// Payez la valeur du tableau des paramètres dans le fichier ASPX qui sera remplacé dans le fichier HTML
178 /// </summary>
179 /// <param name = "param"> </ param>
180 public void SetapxFileParameter (String [] param)
181 {
182 Essayez
183 {
184 if (param.length == this.templateParamCount)
185 this._aspxFileParameter = param;
186 // else // Le nombre est différent de la définition d'origine
187 //
188}
189 Catch (System.Exception ex)
190 {
191 Writerrfile (ex);
192}
193}
194 / ** /// <résumé>
195 /// Démarrer la conversion ASPXTOHTML
196 /// </summary>
197 /// <retourne> La valeur de retour est le nom de fichier après une création réussie </preminds>
198 /// <Remarks> Avant d'appeler cette méthode, il est nécessaire de s'assurer que les méthodes SetTemplateFileParameter et SetAspxFileParameter ont été appelées pour les opérations de valeur de valeur correspondantes </varks>
199 public String startConvert ()
200 {
201 if (this._templatefileparameter.length == this._aspxfileParameter.length)
202 {
203 return writeFile ();
204}
205 else {
206 retour null;
207}
208}
209 / ** /// <résumé>
210 /// Démarrer la conversion ASPXTOHTML
211 /// </summary>
212 /// <param name = "htmlparam"> Array de tous les paramètres dans la page de modèle HTML </ param>
213 /// <param name = "ASPXPARAM"> La page ASPX doit remplacer le tableau de valeur de paramètre dans la page de modèle HTML </param>
214 /// <retourne> La valeur de retour est le nom de fichier après une création réussie </preint>
215 public String startConvert (String [] htmlparam, String [] aspxparam)
216 {
217 // Appelez d'abord les méthodes SetTemplateFileParameter et SetaspxFileParameter pour effectuer des opérations de paiement de valeur
218 SetTemplateFileParameter (htmlparam);
219 setaspxFileParameter (Aspxparam);
220 //
221 String fn = this.startConvert ();
222 //
223 _convertedFileName = fn;
224 //
225 retour fn;
226}
227
228 / ** //// <résumé>
229 /// Utilisez le temps pour ajouter des nombres aléatoires pour générer un nom de fichier
230 /// </summary>
231 /// <retourne> </ retourne>
232 String privé getFileName ()
233 {
234 // Utilisez le temps pour ajouter des nombres aléatoires pour générer un nom de fichier
235 System.Threading.Thread.Sleep (50);
236 String YearsTr = System.DateTime.Now.year.ToString ();
237 String moistr = string.format ("{0: 0 #}", system.datetime.now.month);
238 String Daystr = String.Format ("{0: 0 #}", System.DateTime.Now.Day);
239 String HoursTr = String.Format ("{0: 0 #}", System.DateTime.Now.Hour);
240 String MINUTESTR = String.Format ("{0: 0 #}", System.DateTime.Now.Minute);
241 String secondstr = String.Format ("{0: 0 #}", System.DateTime.Now.second);
242 String millisecondstr = string.format ("{0: 000 #}", System.DateTime.Now.MilliseCond);
243 System.Random rd = new System.Random ();
244 Retour Yearstr + Montstr + Daystr + HoursTr + Minutestr + Secondstr + MillionsEnondstr + String.Format ("{0: 0000 #}", rd.next (100)) + ". Html";
245 // return datetime.now.toString ("yyyymmddhhmmss") + ". Html";
246}
247 / ** //// <Summary>
248 /// Convertir
249 /// </summary>
250 /// <retourne> Renvoie le nom de fichier nommé par le temps </ returns>
251 Private String WriteFile ()
252 {
253
254 // Lire le fichier de modèle
255 String Temp = httpContext.current.server.mappath (this.templateFilePath);
256 StreamReader SR = NULL;
257 String str = "";
258 Essayez
259 {
260 sr = new StreamReader (temp, this.templatehtmlcode);
261 str = sr.readtoend (); // Lire le fichier
262}
263 Catch (exception ex)
264 {
265 //httpContext.current.Response.write(exp.Message);
266 //httpcontext.current.Response.end ();
267 WriteRerrfile (ex);
268}
269 Enfin
270 {
271 sr.close ();
272}
273 // remplacer le contenu
274 // Pour le moment, le fichier de modèle a été lu dans la variable nommée Str
275 pour (int i = 0; i <this.emplateParAmCount; i ++)
276 {
277 str = str.replace (this._templateFileParameter [i], this._aspxFileParameter [i]);
278}
279
280 RETOUR SAVEFILE (STR);
281}
282
283 / ** /// <résumé>
284 ///
285 /// </summary>
286 /// <param name = "Str"> </ param>
287 /// <retourne> </prewets>
288
289 Private String SaveFile (String Str)
290 {
291 // Écrivez un fichier
292 Stream-Writer SW = NULL;
293 Essayez
294 {
295
296 String Path = httpContext.current.server.mappath (this.htmlFilePath);
297 // Nom de fichier HTML
298 String htmlFileName = getFileName ();
299 SW = nouveau streamwriter (path + htmlFileName, false, this.code);
300 SW.Write (STR);
301 SW.Flush ();
302 RETOUR HTMLFILENAME;
303}
304 Catch (exception ex)
305 {
306 WriteRerrfile (ex);
307}
308 Enfin
309 {
310 SW.Close ();
311}
312 retour "";
313}
314
315 / ** /// <résumé>
316 /// Passez URL pour retourner le code HTML à la page Web
317 /// </summary>
318 /// <param name = "URL"> URL </ param>
319 /// <retourne> </prewets>
320 public String getUrltohtml (URL de chaîne)
321 {
322 Essayez
323 {
324 System.net.WebRequest Wreq = System.net.WebRequest.Create (URL);
325 System.net.webResponse uRsp = wreq.getResponse ();
326 System.io.Stream resStream = nutr.getResponseRam ();
327 System.io.StreamReader Reader = new System.io.StreamReader (resstream, System.Text.Encoding.getEncoding ("GB2312"));
328 return SaveFile (Reader.ReadToEnd ());
329
330}
331 Catch (System.Exception ex)
332 {
333 WriteErrFile (ex);
334}
335 retour "";
336}
337 #endregion
338
339
340 Construction #Region Construct
341
342 public aspxtohtml ()
343 {
344 //
345 // TODO: Ajouter la logique du constructeur ici
346 //
347}
348
349 private void SettemplateParAmCount (int templateParamCount)
350 {
351 if (templateParAmCount> 0)
352 this.TemplateParAmCount = templateParAmCount;
353}
354 / ** //// <résumé>
355 /// Fournir le nombre de paramètres à remplacer
356 /// </summary>
357 /// <param name = "TemplateParAmCount"> </ param>
358 public aspxtohtml (int templateParAmCount)
359 {
360 SettemplateParAmCount (templateParAmCount);
361
362}
363 / ** //// <s résumé>
364 ///
365 /// </summary>
366 /// <param name = "TemplateParAmCount"> Nombre de paramètres dans la page de modèle HTML </param>
367 /// <param name = "htmlfilepath"> Le chemin du dossier du fichier html généré </param>
368 /// <param name = "TemplateFilePath"> PATH TAGLE DE TEMPLATE HTML </ param>
369 public aspxtohtml (int templateParAmCount, chaîne htmlfilepath, chaîne templatefilepath)
370 {
371 SettemplateParAmCount (templateParAmCount);
372 this.htmlFilePath = htmlFilePath;
373 this.templateFilePath = templateFilePath;
374
375}
376 #endregion
377
378 #Region
379
380 / ** /// <résumé>
381 /// Écrivez des erreurs dans la méthode de fichier #Region des erreurs d'écriture dans la méthode du fichier
382 /// </summary>
383 /// <param name = "EE"> </param>
384 private void writeerrfile (exception ee)
385 {
386
387 FileStream FS1 = new FileStream (httpContext.current.server.mappath (errLogPath), System.io.FileMode.Apend);
388 Streamwriter SW1 = nouveau streamwriter (FS1);
389 SW1.WriteLine ("***********************************************************************************);
390 SW1.WriteLine ("Date d'erreur:" + System.DateTime.now);
391 SW1.WriteLine ("Description d'erreur:" + ee.Message);
392 SW1.WriteLine ("Nom d'erreur:" + EE.Source);
393 SW1.WriteLine ("Détails:" + ee.ToString ());
394 SW1.WriteLine ("********************************************************************************);
395 SW1.Close ();
396}
397 #endregion
398}
399}
400