Siempre pensé que la generación dinámica de las páginas estáticas no es fácil de hacer. Lo busqué en línea ayer y estaba mareado. En realidad fue muy simple. La idea es probablemente así.
1: Cree una plantilla de página HTML y use una cadena especial para representar los lugares que desea mostrar dinámicamente en esta página (como $ HTMLSTRTR $);
2: En el programa, use esta página HTML para leer una variable de cadena como STR;
3: Use el método de reemplazo de la cadena para reemplazar los caracteres especiales con lo que desea en el primer paso;
4save;
Ok, tan fácil, escribí una clase como esta en C# hoy para manejar las páginas HTML de generación dinámica. Pensé que todavía lo estaba escribiendo en su totalidad. Acabo de entrar en contacto con .NET, así que espero dar consejos.
Nota: ¡Los códigos en esta categoría no son todos originales, algunos códigos se refieren a los códigos de los internautas!
El siguiente es el código para la clase de conversión
Código
1 Uso del sistema;
2using System.Text;
3using System.Web;
4using System.Configuración;
5using System.io;
6namespace solucky
7 {
8/** //// <summary>
9 /// Descripción resumida de ASPXTOHTML.
10 /// Nota: Usando esta clase, puede configurar la clase de plantilla en el archivo web.config. Como se muestra a continuación
11/** //*<AppSettings>
12 <add key = "TemplateFilepath" valor = "htmlmoudel.htm" />
13 <add key = "htmlfilePath" value = "new/"> </d add>
14 <add key = "errlogpath" value = "aspxtohtml_log.txt"> </ add>
15 </AppSettings>*/
16/** /// </summary>
17 clase pública aspxtohtml
18 {
19/** /// <summary>
20 /// El número de parámetros que se reemplazarán en el archivo de plantilla
21 /// </summary>
22 private int _templateParamCount = 0;
23/** /// <summary>
24 /// La ruta donde se encuentra el archivo de plantilla
25 /// </summary>
26 cadena privada _templateFilepath = ConfigurationSettings.appsettings ["TemplateFilepath"];
27/** /// <summary>
28 /// La ruta almacenada en el archivo HTML convertido
29 /// </summary>
30 cadena privada _htmlfilePath = ConfigurationSettings.appsettings ["htmlfilePath"];
31
32/** //// <summary>
33 /// Codificación de la página de plantilla
34 /// </summary>
35 Codificación privada _templatehtmlCode = encoding.getEncoding ("GB2312");
36
37/** /// <summary>
38 /// codificación de archivo convertido
39 /// </summary>
40 codificación privada _code = coding.getEncoding ("GB2312");
41
42/** //// <summary>
43 /// Nombre de archivo HTML convertido
44 /// </summary>
45 cadena privada _convertedFileName = "";
46/** //// <summary>
47 /// parámetros en el archivo de plantilla
48 /// </summary>
49 cadena privada [] _templateFileParameter;
50
51/** /// <summary>
52 /// El valor real del parámetro en el archivo ASPX debe ser reemplazado por el archivo HTML
53 /// </summary>
54 cadena privada [] _asPXFileParameter;
55
56 cadena privada _errlogPath = ConfigurationSettings.AppSettings ["errlogPath"];
57
58 ATRIBUTOS#Atributos de región
59
60/** //// <summary>
61 /// El número de parámetros a reemplazar en el archivo de plantilla
62 /// </summary>
63 Public Int TemplateParamcount
64 {
65 consigue
66 {
67 devuelve esto._templateParamCount;
68}
69 SET // Al asignar el número de parámetros, la matriz real se asigna para los parámetros en el archivo de plantilla y los valores reales en el archivo ASPX para reemplazar los valores reales en el archivo HTML.
70 {
71 if (valor <0)
72 tirar nueva argumentException ();
73
74 if (valor> 0)
75 {
76 this._templateParamCount = valor;
77 // Parámetros en el archivo de plantilla
78 _templateFileParameter = new String [valor];
79 // El valor real del parámetro en el archivo ASPX debe ser reemplazado por el archivo HTML
80 _aspxfileParameter = nueva cadena [valor];
81}
82 más
83 this._templateParamCount = 0;
84}
85}
86
87/** //// <summary>
88 /// La ruta donde se encuentra el archivo de plantilla
89 ///
90 /// </summary>
91 Public String TemplateFilepath
92 {
93 Get {return this._templateFilepath;}
94 set {this._templateFilePath = value;}
95}
96/** /// <summary>
97 /// La ruta almacenada en el archivo HTML convertido
98 /// </summary>
99 Public String HtmlFilepath
100 {
101 Get {return this._htmlfilepath;}
102 establecido {this._htmlfilePath = valor;}
103}
104
105/** /// <summary>
106 /// codificación de archivo de plantilla html
107 /// </summary>
108 TemplatehtmlCode de codificación pública
109 {
110 get {return this._templatehtmlcode;}
111 set {this._templatehtmlcode = encoding.getEncoding (value.ToString ());}
112}
113/** /// <summary>
114 /// codificación
115 /// </summary>
116 Código de codificación pública
117 {
118 Get {return this._code;}
119 set {this._code = encoding.getEncoding (value.toString ());}
120}
121/** /// <summary>
122 /// La ruta del archivo de error se encuentra
123 /// </summary>
124 Cadena pública ErrlogPath
125 {
126 Get {
127 if (! (This._errlogpath == nulo))
128 devuelve esto._errlogpath;
129 más
130 return "aspxtohtml_log.txt";
131}
132 SET {this._errlogPath = valor;}
133}
134
135
136 #Endregion
137
138 Operación#Región Operación
139
140/** /// <summary>
141 /// Obtenga la ruta del archivo relativo donde se encuentra el archivo HTML convertido
142 /// Por ejemplo: si htmlfilePath = "/news/"
143 /// El nombre de archivo HTML convertido es 2005050505.html
144 /// Entonces el valor devuelto es /News/200505050505.html
145 /// </summary>
146 /// <observación> retrocede nulo Si se llama a esta propiedad antes de que se llame el método StartConvert </observación>
147 cadena pública htmlFilevirtualPath
148 {
149 consigue
150 {
151 if (! (This._convertedFileName == ""))
152 devuelve esto.htmlfilepath+this._convertedFileName;
153 más
154 regreso nulo;
155}
156}
157
158/** /// <summary>
159 /// Valor salarial para la matriz de parámetros de la página HTML
160 /// </summary>
161 /// <param name = "param"> </param>
162 public void setTemplateFileParameter (String [] Param)
163 {
164 intenta
165 {
166 if (param.length == this.templateParamCount)
167 this._templateFileParameter = param;
168 // else // El número es diferente de la definición original
169 //
170}
171 Catch (System.Exception EX)
172 {
173 Writeerrfile (ex);
174}
175}
176/** /// <summary>
177 /// Pague el valor para la matriz de parámetros en el archivo ASPX que se reemplazará en el archivo HTML
178 /// </summary>
179 /// <param name = "param"> </param>
180 public void setapxFileParameter (String [] Param)
181 {
182 intenta
183 {
184 if (param.length == this.templateParamCount)
185 this._aspxfileparameter = param;
186 // else // El número es diferente de la definición original
187 //
188}
189 Catch (System.Exception EX)
190 {
191 Writeerrfile (ex);
192}
193}
194/** /// <summary>
195 /// Inicie la conversión de aspxtohtml
196 /// </summary>
197 /// <<vuelve> El valor de retorno es el nombre del archivo después de la creación exitosa </devuelve>
198 /// <<eclansts> Antes de llamar a este método, es necesario asegurarse de que los métodos SetTemplateFileParameter y SetAspxFileParameter se hayan solicitado para las operaciones de pago de valor correspondientes </Observaciones>
199 String Public StartConvert ()
200 {
201 if (this._templateFileParameter.length == this._aspxfileparameter.length)
202 {
203 return WriteFile ();
204}
205 más {
206 regreso nulo;
207}
208}
209/** /// <summary>
210 /// Inicie la conversión de aspxtohtml
211 /// </summary>
212 /// <param name = "htmlparam"> matriz de todos los parámetros en la página de plantilla html </mam>
213 /// <param name = "aspxparam"> La página ASPX debe reemplazar la matriz de valor del parámetro en la página de plantilla HTML </param>
214 /// <surnes> El valor de retorno es el nombre del archivo después de la creación exitosa </devuelve>
215 public String startConvert (string [] htmlparam, string [] aspxparam)
216 {
217 // Primero llame a los métodos SetTemplateFileParameter y SetaspxFileParameter para realizar operaciones de pago de valor
218 SetTemplateFileParameter (htmlparam);
219 setaspxfileparameter (aspxparam);
220 //
221 cadena fn = this.startConvert ();
222 //
223 _ConvertedFileName = fn;
224 //
225 regreso fn;
226}
227
228/** //// <summary>
229 /// Use tiempo para agregar números aleatorios para generar un nombre de archivo
230 /// </summary>
231 /// <surns> </devuelve>
232 cadena privada getFileName ()
233 {
234 // Use el tiempo para agregar números aleatorios para generar un nombre de archivo
235 System.threading.thread.sleep (50);
236 String Yearstr = System.Datetime.Now.Year.ToString ();
237 String Mesesstr = String.Format ("{0: 0#}", system.datetime.now.month);
238 string daystr = string.format ("{0: 0#}", system.datetime.now.day);
239 String Sourstr = String.Format ("{0: 0#}", system.datetime.now.hur);
240 cadena 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 años de retorno TR + MESESTR + DIAYTR + SORSTR + Minutestr + Secondstr + MillionSecondstr + String.Format ("{0: 0000#}", rd.next (100)) + ". Html";
245 // return datetime.now.ToString ("yyyymmddhhmmss")+". Html";
246}
247/** //// <summary>
248 /// convertir
249 /// </summary>
250 /// <miren> Devuelve el nombre del archivo nombrado por tiempo </devuelve>
251 String privado WriteFile ()
252 {
253
254 // Lea el archivo de plantilla
255 cadena temp = httpcontext.current.server.mappath (this.templateFilePath);
256 StreamReader Sr = NULL;
257 cadena str = "";
258 intenta
259 {
260 sr = new StreamReader (temp, this.templatehtmlcode);
261 str = Sr.ReadToend (); // Lee el archivo
262}
263 captura (excepción ex)
264 {
265 //httpcontext.current.response.write(exp.message);
266 //httpcontext.current.response.end ();
267 Writeerrfile (ex);
268}
269 Finalmente
270 {
271 Sr.Close ();
272}
273 // Reemplazar contenido
274 // En este momento, el archivo de plantilla se ha leído en la variable llamada STR
275 para (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 = "str"> </param>
287 /// <surns> </devuelve>
288
289 String privado SaveFile (String Str)
290 {
291 // Escribir un archivo
292 StreamWriter SW = NULL;
293 intenta
294 {
295
296 string ruta = httpcontext.current.server.mappath (this.htmlfilePath);
297 // nombre de archivo html
298 cadena htmlFileName = getFileName ();
299 SW = nuevo StreamWriter (ruta + htmlfileName, falso, this.code);
300 SW.Write (STR);
301 sw.flush ();
302 return htmlFileName;
303}
304 captura (excepción ex)
305 {
306 Writeerrfile (ex);
307}
308 Finalmente
309 {
310 SW.Close ();
311}
312 regreso "";
313}
314
315/** /// <summary>
316 /// Pase en URL para devolver el código HTML a la página web
317 /// </summary>
318 /// <param name = "url"> url </mam>
319 /// <surns> </devuelve>
320 Public String getUrlTOHTML (URL de cadena)
321 {
322 intenta
323 {
324 System.net.WebRequest wreq = system.net.webrequest.create (url);
325 System.net.WebResponse WResp = Wreq.getResponse ();
326 System.io.stream respstream = wresp.getResponseSteam ();
327 System.io.StreamReader Reader = new System.io.streamReader (respstream, system.text.encoding.getEncoding ("GB2312"));
328 return SaveFile (Reader.ReadToend ());
329
330}
331 Catch (System.Exception EX)
332 {
333 Writeerrfile (ex);
334}
335 regreso "";
336}
337 #Endregion
338
339
340 Construcción #Construcción de región
341
342 Public AspXtohtml ()
343 {
344 //
345 // TODO: Agregue la lógica del constructor aquí
346 //
347}
348
349 Void privado SetTemplateParamCount (int TemplateParamCount)
350 {
351 if (TemplateParamCount> 0)
352 this.templateParamCount = TemplateParamCount;
353}
354/** //// <summary>
355 /// Proporcione el número de parámetros que se reemplazarán
356 /// </summary>
357 /// <param name = "TemplateParamCount"> </param>
358 Public AspxToHTML (int TemplateParamCount)
359 {
360 SetTemplateParamCount (TemplateParamCount);
361
362}
363/** //// <summary>
364 ///
365 /// </summary>
366 /// <param name = "TemplateParamCount"> Número de parámetros en la página de plantilla HTML </param>
367 /// <param name = "htmlfilePath"> La ruta de la carpeta del archivo HTML generado </param>
368 /// <param name = "TemplateFilepath"> ruta de página de plantilla html </param>
369 Public AspxTohtml (int TemplateParamCount, String htmlfilePath, cadena TemplateFilepath)
370 {
371 SetTemplateParamCount (TemplateParamCount);
372 this.htmlfilepath = htmlfilePath;
373 this.templateFilepath = TemplateFilepath;
374
375}
376 #Endregion
377
378 #región
379
380/** /// <summary>
381 /// Escribir errores al método de archivo #region Escribir errores al método de archivo
382 /// </summary>
383 /// <param name = "ee"> </param>
384 Void privado WriteRrfile (Excepción EE)
385 {
386
387 FILEStEAM FS1 = nuevo FilErteam (httpcontext.current.server.mappath (errlogPath), system.io.filemode.append);
388 StreamWriter SW1 = New StreamWriter (FS1);
389 SW1.WriteLel ("******************************************************************************************************************************************enan;
390 SW1.WriteLine ("Fecha de error:" + System.Datetime.Now);
391 SW1.WriteLine ("Descripción del error:" + ee.message);
392 SW1.WriteLine ("Nombre de error:" + ee.source);
393 SW1.WriteLine ("Detalles:" + Ee.ToString ());
394 SW1.WriteLine ("****************************************************************************************************************************);
395 sw1.close ();
396}
397 #Endregion
398}
399}
400