Ich dachte immer, dass es nicht einfach ist, statische Seiten dynamisch zu erzeugen. Ich habe gestern online gesucht und war schwindelig. Es war eigentlich sehr einfach. Die Idee ist wahrscheinlich so.
1: Erstellen Sie eine HTML -Seitenvorlage und verwenden Sie eine spezielle Zeichenfolge, um die Orte darzustellen, die Sie auf dieser Seite dynamisch anzeigen möchten (z. B. $ htmlstrstr $).
2: Verwenden Sie im Programm diese HTML -Seite, um eine String -Variable wie str;
3: Verwenden Sie die Ersatzmethode der Zeichenfolge, um die Sonderzeichen durch das zu ersetzen, was Sie im ersten Schritt wollen.
4Save;
OK, so einfach, ich habe heute eine solche Klasse in C# geschrieben, um dynamisch generierende HTML -Seiten zu erzeugen. Ich dachte, ich würde es immer noch vollständig schreiben. Ich bin gerade mit .NET in Kontakt gekommen, also hoffe ich, Ratschläge zu geben.
Hinweis: Die Codes in dieser Kategorie sind nicht alle original, einige Codes beziehen sich auf die Codes von Internetnutzern!
Das Folgende ist der Code für die Conversion -Klasse
Code
1 -UNS -System;
2USS System.text;
3USS System.Web;
4USS System.Configuration;
5USS System.io;
6NameSpace Solucky
7 {
8/** //// <summary>
9 /// Zusammenfassungsbeschreibung von AspxtoHtml.
10 /// HINWEIS: Mit dieser Klasse können Sie die Vorlagenklasse in der Datei web.config konfigurieren. Wie unten gezeigt
11/** //*<Appsettings>
12 <add key = "templateFilepath" value = "htmlmoudel.htm" />
13 <add key = "htmlfilepath" value = "new/"> </add>
14 <add key = "errlogpath" value = "ASPXTOHTML_LOG.TXT"> </add>
15 </Appsettings>*/
16/** /// </summary>
17 öffentliche Klasse AspxtoHtml
18 {
19/** /// <summary>
20 /// Die Anzahl der Parameter, die in der Vorlagendatei ersetzt werden sollen
21 /// </summary>
22 private int _templateParamCount = 0;
23/** /// <summary>
24 /// der Pfad, auf dem sich die Vorlagendatei befindet
25 /// </summary>
26 private String _templateFilePath = configurationsSettings.Appsettings ["templateFilepath"];
27/** /// <summary>
28 /// Der in der konvertierte HTML -Datei gespeicherte Pfad
29 /// </summary>
30 private String _htmlfilepath = configurationsSettings.Appsetings ["htmlfilepath"];
31
32/** //// <summary>
33 /// Vorlagenseitencodierung
34 /// </summary>
35 private codierung _templateHtmlcode = coding.getEcoding ("gb2312");
36
37/** /// <summary>
38 /// konvertierte Dateikodierung
39 /// </summary>
40 private codierung _code = coding.getEcoding ("gb2312");
41
42/** //// <summary>
43 /// konvertierte HTML -Dateiname
44 /// </summary>
45 private String _convertedFileName = "";
46/** //// <summary>
47 /// Parameter in der Vorlagendatei
48 /// </summary>
49 private String [] _templateFileParameter;
50
51/** /// <summary>
52 /// Der tatsächliche Wert des Parameters in der ASPX -Datei sollte durch die HTML -Datei ersetzt werden
53 /// </summary>
54 private String [] _aspxfileParameter;
55
56 private String _errlogpath = configurationssettings.Appsettings ["ErrlogPath"];
57
58 Attribute#Region Attribute
59
60/** //// <summary>
61 /// Die Anzahl der Parameter, die in der Vorlagendatei ersetzt werden sollen
62 /// </summary>
63 öffentliche int templateParamcount
64 {
65 bekommen
66 {
67 return this._templateParamCount;
68}
69 SET // Bei der Zuweisung der Anzahl der Parameter wird das tatsächliche Array für die Parameter in der Vorlagendatei und die tatsächlichen Werte in der ASPX -Datei zugeteilt, um die tatsächlichen Werte in der HTML -Datei zu ersetzen.
70 {
71 if (Wert <0)
72 neue ArgumentException () werfen;
73
74 if (Wert> 0)
75 {
76 this._templateParamCount = Wert;
77 // Parameter in der Vorlagendatei
78 _TemplateFileParameter = neuer String [Wert];
79 // Der tatsächliche Wert des Parameters in der ASPX -Datei sollte durch die HTML -Datei ersetzt werden
80 _aspxfileParameter = neuer String [Wert];
81}
82 sonst
83 this._templateParamCount = 0;
84}
85}
86
87/** //// <summary>
88 /// der Pfad, auf dem sich die Vorlagendatei befindet
89 ////
90 /// </summary>
91 Public String TemplateFilePath
92 {
93 Get {return this._templateFilepath;}
94 set {this._templateFilepath = value;}
95}
96/** /// <summary>
97 /// Der in der konvertierte HTML -Datei gespeicherte Pfad
98 /// </summary>
99 Public String HTMLFilePath
100 {
101 Get {return this.htmlfilepath;}
102 set {this._htmlfilepath = value;}
103}
104
105/** /// <summary>
106 /// HTML -Vorlagendatei -Codierung
107 /// </summary>
108 Public Coding TemplateHTMLCode
109 {
110 Get {return this._templateHtmlCode;}
111 set {this._templateHtmlCode = coding.getEcoding (value.toString ());};};
112}
113/** /// <summary>
114 /// Codierung
115 /// </summary>
116 öffentlicher Codierungscode
117 {
118 Get {return this._code;}
119 set {this._code = coding.getEcoding (value.toString ());};
120}
121/** /// <summary>
122 /// Der Pfad der Fehlerdatei befindet sich
123 /// </summary>
124 öffentlicher String errlogPath
125 {
126 GET {
127 if (! (This.rerrlogpath == null))
128 return this._errlogPath;
129 sonst
130 return "ASPXTOHTML_LOG.TXT";
131}
132 set {this._errlogpath = value;}
133}
134
135
136 #endregion
137
138 Betrieb#Region Operation
139
140/** /// <summary>
141 /// Erhalten Sie den relativen Dateipfad, in dem sich die konvertierte HTML -Datei befindet
142 /// zum Beispiel: wenn htmlfilepath = "/news/"
143 /// Der konvertierte HTML -Dateiname lautet 2005050505.html
144 /// dann ist der zurückgegebene Wert /news/200505050505.html
145 /// </summary>
146 /// <bemerkungen> null zurückgeben, wenn diese Eigenschaft aufgerufen wird
147 Public String htmlFilevirtualPath
148 {
149 GET
150 {
151 if (! (This._convertedFileName == ""))
152 return this.htmlfilepath+this._convertedFileName;
153 sonst
154 Rückkehr null;
155}
156}
157
158/** /// <summary>
159 /// Zahlenwert für das Parameter -Array des HTML -Seiten -Parameters zahlen
160 /// </summary>
161 /// <param name = "param"> </param>
162 Public Void SeetemplateFileParameter (String [] Param)
163 {
164 Versuchen Sie
165 {
166 if (param.length == this.templateParamCount)
167 this._templateFileParameter = param;
168 // else // Die Zahl unterscheidet sich von der ursprünglichen Definition
169 //
170}
171 Catch (System.Exception Ex)
172 {
173 WriteRfile (Ex);
174}
175}
176/** /// <summary>
177 /// Zahlen Sie den Wert für das Parameter -Array in der ASPX -Datei, die in der HTML -Datei ersetzt wird
178 /// </summary>
179 /// <param name = "param"> </param>
180 Public void setAPXFileParameter (String [] Param)
181 {
182 Versuch
183 {
184 if (param.length == this.templateParamCount)
185 this._aspxfileParameter = param;
186 // else // Die Zahl unterscheidet sich von der ursprünglichen Definition
187 //
188}
189 Catch (System.Exception Ex)
190 {
191 WriteRfile (Ex);
192}
193}
194/** /// <summary>
195 /// ASPXTOHTML -Konvertierung starten
196 /// </summary>
197 /// <zurückgegeben> Rückgabewert ist der Dateiname nach erfolgreicher Erstellung </returns>
198 /// <bemerkungen> Bevor Sie diese Methode aufrufen, müssen Sie sicherstellen
199 öffentliche String StartConvert ()
200 {
201 if (this._templateFileParameter.length == this._aspxfileParameter.length)
202 {
203 return writeFile ();
204}
205 sonst {
206 Rückkehr null;
207}
208}
209/** /// <summary>
210 /// ASPXTOHTML -Konvertierung starten
211 /// </summary>
212 /// <param name = "htmlparam"> Array aller Parameter auf der HTML -Vorlage Seite </param>
213 /// <param name = "Aspxparam"> Die ASPX -Seite sollte das Parameterwert -Array in der Seite HTML -Vorlage ersetzen </param>
214 /// <zurückgegeben> Rückgabewert ist der Dateiname nach erfolgreicher Erstellung </returns>
215 public String startConvert (String [] htmlparam, String [] AspxParam)
216 {
217 // Rufen Sie zuerst die SETMplateFileParameter und setaPXFileParameter -Methoden an, um Wertzahlungsvorgänge durchzuführen
218 SettemplateFileParameter (HTMLParam);
219 setaspxFileParameter (AspxParam);
220 //
221 String fn = this.startConvert ();
222 //
223 _convertedFileName = fn;
224 //
225 Return Fn;
226}
227
228/** //// <summary>
229 /// Zeit, um zufällige Nummern hinzuzufügen, um einen Dateinamen zu generieren
230 /// </summary>
231 /// <zurückgegeben> </returns>
232 private String getFileName ()
233 {
234 // Verwenden Sie Zeit, um zufällige Nummern hinzuzufügen, um einen Dateinamen zu generieren
235 System.Threading.Thread.sleep (50);
236 String YearsTR = System.DateTime.now.year.toString ();
237 String monatstr = string.format ("{0: 0#}", System.Datetime.now.month);
238 String DayTR = String.Format ("{0: 0#}", System.datetime.now.day);
239 String stundentr = string.format ("{0: 0#}", System.Datetime.now.Hour);
240 String minUuteStr = 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 = neues System.Random ();
244 Return YearsTR + Monatstr + DayTR + Stundenstr + MinuteStr + Secondstr + MillionsecondStr + String.Format ("{0: 0000#}", rd.next (100)) + ". Html";
245 // return dateTime.now.toString ("yyyymmddhhmms")+". Html";
246}
247/** //// <summary>
248 /// konvertieren
249 /// </summary>
250 /// <zurückgegeben> gibt den von Time </zurückgegebenen Dateinamen zurück </zurücksend>
251 private String writefile ()
252 {
253
254 // Vorlagendatei lesen
255 String temp = httpcontext.current.server.mappath (this.templateFilePath);
256 StreamReader SR = NULL;
257 String str = "";
258 Versuchen Sie
259 {
260 sr = neuer StreamReader (temp, this.templateHtmlCode);
261 str = sr.readtoend (); // Lesen Sie die Datei
262}
263 Catch (Ausnahme ex)
264 {
265 //httpcontext.current.Response.write(exp.Message);
266 //httpcontext.current.Response.end ();
267 WriteRfile (Ex);
268}
269 Schließlich
270 {
271 sr.close ();
272}
273 // Inhalt ersetzen
274 // zu diesem Zeitpunkt wurde die Vorlagendatei in die Variable namens STR gelesen
275 für (int i = 0; i <this.templateParamCount; i ++)
276 {
277 STR = Str.Replace (this._templateFileParameter [i], this._aspxfileParameter [i]);
278}
279
280 Return SaveFile (STR);
281}
282
283/** /// <summary>
284 ///
285 /// </summary>
286 /// <param name = "st"> </param>
287 /// <returns> </returns>
288
289 Private String SaveFile (String Str)
290 {
291 // eine Datei schreiben
292 Streamwriter SW = NULL;
293 Versuch
294 {
295
296 string path = httpcontext.current.server.mappath (this.htmlfilepath);
297 // HTML -Dateiname
298 String htmlfilename = getFileName ();
299 SW = neuer StreamWriter (Pfad + HtmlFileName, False, this.code);
300 SW.Write (STR);
301 sw.flush ();
302 Return HtmlFileName;
303}
304 Catch (Ausnahme ex)
305 {
306 WriteRfile (Ex);
307}
308 Schließlich
309 {
310 sw.close ();
311}
312 Return "";
313}
314
315/** /// <summary>
316 /// in die URL übergeben, um den HTML -Code an die Webseite zurückzugeben
317 /// </summary>
318 /// <param name = "url"> url </param>
319 /// <returns> </returns>
320 Public String Geturltohtml (String -URL)
321 {
322 Versuch
323 {
324 System.net.WebRequest WREQ = System.net.WebRequest.Create (URL);
325 System.net.Webresponse Wresp = WREQ.GetResponse ();
326 system.io.stream repstream = Wresp.GetResponStream ();
327 System.io.StreamReader Reader = new System.io.StreamReader (repstream, System.text.encoding.getEcoding ("GB2312"));
328 return SaveFile (reader.readtoend ());
329
330}
331 catch (System.Exception ex)
332 {
333 WriteRfile (Ex);
334}
335 return "";
336}
337 #endregion
338
339
340 Konstrukt #region -Konstrukt
341
342 öffentliches AspxtoHtml ()
343 {
344 //
345 // TODO: Fügen Sie hier Konstruktorlogik hinzu
346 //
347}
348
349 private void setzteParamcount (int templateParamcount)
350 {
351 if (TemplateParamCount> 0)
352 this.templateParamCount = templateParamCount;
353}
354/** //// <summary>
355 /// Geben Sie die Anzahl der zu ersetzenden Parameter an
356 /// </summary>
357 /// <param name = "templateParamCount"> </param>
358 public ASPXTOHTML (int templateParamCount)
359 {
360 SETTEMPLEPARAMCOUNT (TemplateParamCount);
361
362}
363/** //// <summary>
364 ///
365 /// </summary>
366 /// <param name = "templateParamCount"> Anzahl der Parameter in der Seite HTML -Vorlage </param>
367 /// <param name = "htmlfilepath"> Der Ordnerpfad der generierten HTML -Datei </param>
368 /// <param name = "templateFilepath"> HTML -Vorlagenseite Pfad </param>
369 public ASPXTOHTML (int templateParamCount, String htmlfilepath, String TemplateFilePath)
370 {
371 SESSEMPETPARAMCOUNT (TemplateParamCount);
372 this.htmlfilepath = htmlfilepath;
373 this.templateFilepath = templateFilePath;
374
375}
376 #endregion
377
378 #region
379
380/** /// <summary>
381 /// Fehler in die Dateimethode schreiben #region Schreiben Sie Fehler zur Dateimethode.
382 /// </summary>
383 /// <param name = "ee"> </param>
384 Private void Writeerrfile (Ausnahme EE)
385 {
386
387 fileStream fs1 = neuer fileStream (httpcontext.current.server.mappath (ErrlogPath), System.io.filemode.Append);
388 Streamwriter SW1 = neuer StreamWriter (FS1);
389 SW1.WriteLine ("*************
390 SW1.WriteLine ("Fehlerdatum:" + system.datetime.now);
391 SW1.WriteLine ("Fehlerbeschreibung:" + ee.message);
392 SW1.WriteLine ("Fehlername:" + ee.source);
393 SW1.WriteLine ("Details:" + ee.toString ());
394 SW1.WriteLine ("*********
395 SW1.CLOSE ();
396}
397 #endregion
398}
399}
400