ASP. NET MVC Method for Generating Static Pages

This article mainly describes the static method of page in asp. NET mvc. For websites, generating pure html static pages can not only benefit seo, but also reduce the load capacity of websites and improve the performance of websites.

1. Pay the original code that encapsulates the static page first:

public class Common
{
  #region  Object of the template page Html Code 
  /// <summary>
  ///  Object of the page Html Code 
  /// </summary>
  /// <param name="url"> Template page path </param>
  /// <param name="encoding"> Page coding </param>
  /// <returns></returns>
  public static string GetHtml(string url, System.Text.Encoding encoding)
  {
    byte[] buf = new WebClient().DownloadData(url);
    if (encoding != null)
    {
      return encoding.GetString(buf);
    }
    string html = System.Text.Encoding.UTF8.GetString(buf);
    encoding = GetEncoding(html);
    if (encoding == null || encoding == System.Text.Encoding.UTF8)
    {
      return html;
    }
    return encoding.GetString(buf);
  }

  /// <summary>
  ///  Get the encoding of the page 
  /// </summary>
  /// <param name="html">Html Source code </param>
  /// <returns></returns>
  public static System.Text.Encoding GetEncoding(string html)
  {
    string pattern = @"(?i)\bcharset=(?<charset>[-a-zA-Z_0-9]+)";
    string charset = Regex.Match(html, pattern).Groups["charset"].Value;
    try
    {
      return System.Text.Encoding.GetEncoding(charset);
    }
    catch (ArgumentException)
    {
      return null;
    }
  }
  #endregion

  #region  Used to generate Html Static page 
  /// <summary>
  ///  Create a static file 
  /// </summary>
  /// <param name="result">Html Code </param>
  /// <param name="createpath"> Generation path </param>
  /// <returns></returns>
  public static bool CreateFileHtmlByTemp(string result, string createpath)
  {
    if (!string.IsNullOrEmpty(result))
    {
      if (string.IsNullOrEmpty(createpath))
      {
        createpath = "/default.html";
      }
      string filepath = createpath.Substring(createpath.LastIndexOf(@"\"));
      createpath = createpath.Substring(0, createpath.LastIndexOf(@"\"));
      if (!Directory.Exists(createpath))
      {
        Directory.CreateDirectory(createpath);
      }
      createpath = createpath + filepath;

      try
      {
        FileStream fs2 = new FileStream(createpath, FileMode.Create);
        StreamWriter sw = new StreamWriter(fs2, new System.Text.UTF8Encoding(false));// Removal UTF-8 BOM
        sw.Write(result);
        sw.Close();
        fs2.Close();
        fs2.Dispose();
        return true;
      }
      catch (Exception ex)
      {
        throw ex;
      }
    }
    return false;
  }
  #endregion

  #region  Invoke static templates and pass data model entity classes   Create Html Static page 
  /// <summary>
  ///  Parsing Templates to Generate Static Pages 
  /// </summary>
  /// <param name="temppath"> Template address </param>
  /// <param name="path"> Static page address </param>
  /// <param name="t"> Data model </param>
  /// <returns></returns>
  public static bool CreateStaticPage<T>(string temppath, string path, T t)
  {
    try
    {
      // Get a template Html
      string TemplateContent = GetHtml(temppath, System.Text.Encoding.UTF8);

      // Initialization result 
      string result = string.Empty;

      // Parsing Templates to Generate Static Pages Html Code 
      result = Razor.Parse(TemplateContent, t);

      // Create a static file 
      return CreateFileHtmlByTemp(result, path);
    }
    catch (Exception e)
    {
      throw e;
    }
  }
  #endregion
}

2. Call the method (create a multithread to execute, and the effect will be better):

// Instantiate calling method 
Task tk = new Task(CreateStaticHtml);
tk.Start();
// Statically calling methods 
Task.Factory.StartNew(() => CreateStaticHtml());

3. Encapsulated static method:

/// <summary>
///  Create a static page 
/// </summary>
public void CreateStaticHtml()
{
  using (BangLiEntities bangLi = new BangLiEntities())
  {
    View_Home view_Home = new View_Home();
    view_Home.CommandAdExtendList = Dal.CommandAdDal.Instance(bangLi).GetInit().ToList();
    view_Home.NewsList = bangLi.News.OrderByDescending(u => u.AddDateTime).Take(5).ToList();
    view_Home.NewsExtendList = Dal.NewsDal.Instance(bangLi).GetInit().OrderByDescending(u => u.AddDateTime).Take(5).ToList();
    view_Home.News = Dal.NewsDal.Instance(bangLi).GetInit().Where(u => u.Id == 3).SingleOrDefault();
    string TemplateContent = Common.GetHtml(Server.MapPath("/Views/SourceHtml/Home/Index.cshtml"), System.Text.Encoding.UTF8);
    // Initialization result 
    string result = string.Empty;
    // Parsing Templates to Generate Static Pages Html Code 
    result = Razor.Parse(TemplateContent, view_Home);
    // Create a static file 
    Common.CreateFileHtmlByTemp(result, Server.MapPath("/Resource/Manage/Html/Home/Index.html"));
  }
}

4. If the first page is executed, you can execute a filter before executing Action:

public class MyFirstHomeAttribute:ActionFilterAttribute
{
  public override void OnActionExecuting(ActionExecutingContext filterContext)
  {
    var context = filterContext.HttpContext;
    context.Session["IsStaticHtml"] = false;
    string path = context.Server.MapPath("/Resource/Manage/Html/Home/Index.html");
    if (System.IO.File.Exists(path))
    {
      string html = System.IO.File.ReadAllText(path);
      context.Response.Write(html);
      context.Session["IsStaticHtml"] = true;
      context.Response.End();
    }
  }
}

5. Execute the home page:

[MyFirstHome]
public ActionResult Index()
{
  View_Home view_Home = null;
  var IsStaticHtml = Convert.ToBoolean(Session["IsStaticHtml"]);
  if (!IsStaticHtml)
  {
    view_Home = new View_Home();
    using (BangLiEntities bangLi = new BangLiEntities())
    {
      view_Home.CommandAdExtendList = Dal.CommandAdDal.Instance(bangLi).GetInit().ToList();
      view_Home.NewsExtendList = Dal.NewsDal.Instance(bangLi).GetInit().OrderByDescending(u => u.AddDateTime).Take(5).ToList();
          
    }
    return View(view_Home);
  }
  else
  {
    return null;
  }
}

Can let a hyperlink or jump address to jump directly to a static html page, the speed will be faster;