Eu sempre pensei que não é fácil gerar páginas estáticas dinamicamente. Olhei online ontem e fiquei tonto. Na verdade, era muito simples. A ideia é provavelmente assim.
1: Crie um modelo de página HTML e use uma string especial para representar os lugares que você deseja exibir dinamicamente nesta página (como $ htmlstrstr $);
2: No programa, use esta página HTML para ler uma variável de string como STR;
3: Use o método de substituição da string para substituir os caracteres especiais pelo que você deseja na primeira etapa;
4Save;
Ok, tão fácil, escrevi uma classe como essa em C# hoje para lidar com as páginas HTML genericamente geradoras. Eu pensei que ainda estava escrevendo na íntegra. Acabei de entrar em contato com .NET, então espero dar conselhos.
Nota: Os códigos nesta categoria não são todos originais, alguns códigos se referem aos códigos de internautas!
A seguir, o código para a classe de conversão
Código
1 sistema de uso;
2Using System.Text;
3Using System.Web;
4Using System.Configuration;
5Using System.io;
6NamesPace Solucky
7 {
8/** //// <summary>
9 /// Descrição do resumo de aspxtohtml.
10 /// Nota: Usando esta classe, você pode configurar a classe de modelo no arquivo web.config. Como mostrado abaixo
11/** //*<PapSettings>
12 <add key = "templateFilePath" value = "htmlmoudel.htm" />
13 <add key = "htmlfilepath" value = "new/"> </dwd>
14 <add key = "errlogpath" value = "aspxtohtml_log.txt"> </dact>
15 </appSettings>*/
16/** /// </summary>
17 classe pública aspxtohtml
18 {
19/** /// <summary>
20 /// o número de parâmetros a serem substituídos no arquivo de modelo
21 /// </summary>
22 privado int _templateParamCount = 0;
23/** /// <summary>
24 /// o caminho onde o arquivo de modelo está localizado
25 /// </summary>
26 String privada _TemplateFilePath = Configurações
27/** /// <summary>
28 /// o caminho armazenado no arquivo HTML convertido
29 /// </summary>
30 String privada _htmlfilepath = configurationsettings.appSettings ["htmlfilepath"];
31
32/** //// <summary>
33 /// codificação da página de modelo
34 /// </summary>
35 codificação privada _templatehtmlcode = coding.getEncoding ("gb2312");
36
37/** /// <summary>
38 /// codificação de arquivo convertido
39 /// </summary>
40 codificação privada _code = coding.getEncoding ("gb2312");
41
42/** //// <summary>
43 /// Nome do arquivo HTML convertido
44 /// </summary>
45 String privada _ConvertedFilename = "";
46/** //// <summary>
47 /// parâmetros no arquivo de modelo
48 /// </summary>
49 String privada [] _TemplateFileParameter;
50
51/** /// <summary>
52 /// O valor real do parâmetro no arquivo ASPX deve ser substituído pelo arquivo html
53 /// </summary>
54 String privada [] _aspxFileParameter;
55
56 String privada _errLogPath = Configurationsettings.appSettings ["errlogPath"];
57
58 Atributos#Atributos da região
59
60/** //// <summary>
61 /// o número de parâmetros a serem substituídos no arquivo de modelo
62 /// </summary>
63 Public Int TemplateParamCount
64 {
65 Get
66 {
67 Retorne this._templateParamCount;
68}
69 Defina // Ao alocar o número de parâmetros, a matriz real é alocada para os parâmetros no arquivo de modelo e os valores reais no arquivo ASPX para substituir os valores reais no arquivo HTML.
70 {
71 se (valor <0)
72 lançar novo argumentException ();
73
74 se (valor> 0)
75 {
76 this._templateparamCount = value;
77 // parâmetros no arquivo de modelo
78 _TemplateFileParameter = new String [Value];
79 // O valor real do parâmetro no arquivo ASPX deve ser substituído pelo arquivo html
80 _aspxFileParameter = new String [valor];
81}
82 else
83 this._templateParamCount = 0;
84}
85}
86
87/** //// <summary>
88 /// o caminho onde o arquivo de modelo está localizado
89 ///
90 /// </summary>
91 Public String TemplateFilePath
92 {
93 Obtenha {return this._templateFilePath;}
94 set {this._templateFilePath = value;}
95}
96/** /// <summary>
97 /// o caminho armazenado no arquivo HTML convertido
98 /// </summary>
99 String pública htmlfilepath
100 {
101 Obtenha {return this._htmlfilepath;}
102 set {this._htmlfilepath = value;}
103}
104
105/** /// <summary>
106 /// codificação de arquivo de modelo html
107 /// </summary>
108 modelo de codificação pública
109 {
110 Obtenha {return this._templateHtmlCode;}
111 set {this._templatehtmlcode = coding.getEncoding (value.toString ());}
112}
113/** /// <summary>
114 /// codificação
115 /// </summary>
116 Código de codificação pública
117 {
118 Obtenha {return this._code;}
119 set {this._code = coding.getEncoding (value.toString ());}
120}
121/** /// <summary>
122 /// O caminho do arquivo de erro está localizado
123 /// </summary>
124 Public String ErrLogPath
125 {
126 Obtenha {
127 se (! (This._errlogPath == null))
128 Retorne this._errLogPath;
129 else
130 retornar "aspxtohtml_log.txt";
131}
132 set {this._errLogPath = value;}
133}
134
135
136 #endregion
137
138 Operação#Operação da região
139
140/** /// <summary>
141 /// Obtenha o caminho de arquivo relativo onde o arquivo HTML convertido está localizado
142 /// por exemplo: se htmlfilepath = "/news/"
143 /// O nome do arquivo HTML convertido é 2005050505.html
144 /// o valor retornado é /news/200505050505.html
145 /// </summary>
146 /// <Observações> Retorne NULL Se essa propriedade for chamada antes que o método StartConvert seja chamado </muils>
147 Public String htmlfilevirtualpath
148 {
149 Get
150 {
151 if (! (This._convertedFilename == "")))
152 Retorne this.htmlfilepath+this._convertedFilename;
153 else
154 retornar nulo;
155}
156}
157
158/** /// <summary>
159 /// Valor de pagamento para a matriz de parâmetros da página HTML
160 /// </summary>
161 /// <param name = "param"> </param>
162 Public void SettemplateFileParameter (String [] param)
163 {
164 Tente
165 {
166 if (param.length == this.templateParamCount)
167 this._templateFileParameter = param;
168 // else // O número é diferente da definição original
169 //
170}
171 Catch (System.Exception Ex)
172 {
173 WRITHERERRFILE (EX);
174}
175}
176/** /// <summary>
177 /// pague o valor pela matriz de parâmetros no arquivo ASPX que será substituído no arquivo html
178 /// </summary>
179 /// <param name = "param"> </param>
180 Public void SetapXFileParameter (String [] param)
181 {
182 Tente
183 {
184 if (param.length == this.templateParamCount)
185 this._aspxFileParameter = param;
186 // else // O número é diferente da definição original
187 //
188}
189 Catch (System.Exception Ex)
190 {
191 WRITHERERRFILE (EX);
192}
193}
194/** /// <summary>
195 /// Iniciar a conversão de aspxtohtml
196 /// </summary>
197 /// <Trackns> O valor de retorno é o nome do arquivo após a criação bem -sucedida </lortns>
198 /// <Observações> Antes de chamar esse método, é necessário garantir que os métodos SettemplateFileParameter e SetaspxFileParameter tenham sido convocados para operações de pagamento de valor correspondentes </observações>
199 public string startConvert ()
200 {
201 if (this._templateFileParameter.Length == this._aspxFileParameter.length)
202 {
203 return writefile ();
204}
205 else {
206 Retorno nulo;
207}
208}
209/** /// <summary>
210 /// Iniciar a conversão aspxtohtml
211 /// </summary>
212 /// <param name = "htmlparam"> Array de todos os parâmetros na página do modelo html </aman>
213 /// <param name = "aspxparam"> A página ASPX deve substituir a matriz de valor do parâmetro na página do modelo html </am Param>
214 /// <Trackns> O valor de retorno é o nome do arquivo após a criação bem -sucedida </lortns>
215 Public String StartConvert (String [] htmlparam, String [] aspxparam)
216 {
217 // Ligue para os métodos SettemplateFileParameter e SetaspxFileParameter para executar operações de pagamento de valor
218 SettemplateFileParameter (htmlparam);
219 setaPaspxFileParameter (aspxparam);
220 //
221 String fn = this.startConvert ();
222 //
223 _convertedFilename = fn;
224 //
225 Retornar FN;
226}
227
228/** //// <summary>
229 /// Use o tempo para adicionar números aleatórios para gerar um nome de arquivo
230 /// </summary>
231 /// <Trackns> </lortns>
232 String privada getFileName ()
233 {
234 // Use o tempo para adicionar números aleatórios para gerar um nome de arquivo
235 System.Threading.Thread.Sleep (50);
236 String anostr = System.dateTime.now.year.toString ();
237 String mesestr = string.format ("{0: 0#}", system.dateTime.now.month);
238 String Daytr = String.Format ("{0: 0#}", System.dateTime.now.day);
239 String Hourstr = String.Format ("{0: 0#}", System.dateTime.now.hour);
240 String minuteSt = string.format ("{0: 0#}", system.dateTime.now.minute);
241 String SecondStr = String.Format ("{0: 0#}", System.dateTime.now.second);
242 String milisEcondstr = string.format ("{0: 000#}", system.dateTime.now.millisEcond);
243 System.Random Rd = new System.Random ();
244 Ano de retorno + mesestr + Days + hours + MinuteST + SecondStr + MillionSecondstr + String.Format ("{0: 0000#}", RD.Next (100) + ". Html";
245 // Return DateTime.now.tostring ("yyyymmddhhmmss")+". Html";
246}
247/** //// <summary>
248 /// converter
249 /// </summary>
250 /// <Returns> Retorna o nome do arquivo nomeado por Time </lackns>
251 Private String Writefile ()
252 {
253
254 // LEI
255 String temp = httpcontext.current.server.mappath (this.templateFilePath);
256 StreamReader sr = null;
257 String str = "";
258 tente
259 {
260 sr = new streamReader (temp, this.templateHtmlCode);
261 str = sr.readtoEnd (); // Leia o arquivo
262}
263 Catch (Exceção Ex)
264 {
265 //httpContext.current.Response.write(exp.message);
266 //httpContext.current.Response.end ();
267 WRITHERERRFILE (EX);
268}
269 Finalmente
270 {
271 sr.close ();
272}
273 // Substitua o conteúdo
274 // Neste momento, o arquivo de modelo foi lido na variável chamada str
275 para (int i = 0; i <this.TemplateParamCount; i ++)
276 {
277 str = str.place (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 /// <lorpns> </lortns>
288
289 Private String SaveFile (String str)
290 {
291 // Escreva um arquivo
292 StreamWriter SW = NULL;
293 tente
294 {
295
296 String Path = httpContext.current.server.mappath (this.htmlfilepath);
297 // Nome do arquivo html
298 String htmlfilename = getFileName ();
299 SW = new StreamWriter (caminho + htmlfileName, false, this.code);
300 SW.WRITE (STR);
301 sw.flush ();
302 retornar htmlfilename;
303}
304 Catch (Exceção Ex)
305 {
306 WRITHERERRFILE (EX);
307}
308 Finalmente
309 {
310 sw.close ();
311}
312 retornar "";
313}
314
315/** /// <summary>
316 /// Passe no URL para retornar o código HTML para a página da web
317 /// </summary>
318 /// <param name = "url"> url </param>
319 /// <lorpns> </lortns>
320 Public String getUrltohtml (URL da string)
321 {
322 Tente
323 {
324 System.net.webrequest wreq = system.net.webrequest.create (url);
325 System.net.WebResponse wresp = wreq.getResponse ();
326 System.io.Stream respStream = wresp.getResponsestream ();
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 WRITERERRFILE (EX);
334}
335 retornar "";
336}
337 #endregion
338
339
340 Construct #region Construct
341
342 Public Aspxtohtml ()
343 {
344 //
345 // TODO: Adicione a lógica do construtor aqui
346 //
347}
348
349 private void SettemplateParamCount (int modeloParamCount)
350 {
351 se (templateparamCount> 0)
352 this.TemplateParamCount = templateParamCount;
353}
354/** //// <summary>
355 /// fornece o número de parâmetros a serem substituídos
356 /// </summary>
357 /// <param name = "templateparamCount"> </param>
358 ASPXTOHTML PUBLICO (INT MOTEMPLAPEPARAMCOUNT)
359 {
360 SettemplateParamCount (templateParamCount);
361
362}
363/** //// <summary>
364 ///
365 /// </summary>
366 /// <param name = "templateparamCount"> Número de parâmetros na página de modelo html </amul>
367 /// <param name = "htmlfilepath"> o caminho da pasta do arquivo html gerado </am>
368 /// <param name = "templatefilepath"> html modelo de página caminho </param>
369 Public Aspxtohtml (int templateParamCount, String htmlfilepath, String templateFilePath)
370 {
371 SettemplateParamCount (templateParamCount);
372 this.htmlfilepath = htmlfilepath;
373 this.TemplateFilePath = templateFilePath;
374
375}
376 #endregion
377
378 #Region
379
380/** /// <summary>
381 /// Escreva erros para o método do arquivo #Region Write Errs to File Method
382 /// </summary>
383 /// <param name = "ee"> </param>
384 Private Void Writeerrfile (Exceção EE)
385 {
386
387 filestream fs1 = new filestream (httpcontext.current.server.mappath (errlogPath), system.io.filemode.append);
388 StreamWriter sw1 = new StreamWriter (FS1);
389 SW1.Writine ("***********************************************************
390 SW1.WriteLine ("Data de erro:" + System.DateTime.now);
391 SW1.WriteLine ("Descrição do erro:" + ee.Message);
392 SW1.WriteLine ("Nome do erro:" + ee.source);
393 SW1.WriteLine ("Detalhes:" + ee.toString ());
394 SW1.Writine ("*******************************************************
395 sw1.close ();
396}
397 #endregion
398}
399}
400