/// <summary>
   ///  实现XML格式 站点地图输出
   ///  By:rhythmk.cnblogs.com
   /// </summary>
    public class SitemapResult : ActionResult
    {
        public SitemapResult(Sitemap sitemap)
        {
            this.Sitemap = sitemap;
        }

        public Sitemap Sitemap { get; private set; }

        public override void ExecuteResult(ControllerContext context)
        {
            context.HttpContext.Response.ContentType = "text/xml";
            XmlSerializer serializer = new XmlSerializer(typeof(Sitemap));
            serializer.Serialize(context.HttpContext.Response.Output,
                                 this.Sitemap);
        }
    }

    /// <summary>
    /// 站点地图实体
    ///  By:rhythmk.cnblogs.com
    /// </summary>
    [XmlRoot(ElementName = "urlset", Namespace = "http://www.sitemaps.org/schemas/sitemap/0.9")]
    [Serializable]
    public class Sitemap : List<SitemapUrl>
    {


        [XmlInclude(typeof(SitemapUrl))]
        public void Serialize(TextWriter writer)
        {
            XmlSerializer serializer = new XmlSerializer(typeof(Sitemap));
            XmlTextWriter xmlTextWriter = new XmlTextWriter(writer);
            serializer.Serialize(xmlTextWriter,
                                 this);
        }


    }

    [XmlRoot(ElementName = "url")]
    [XmlType(TypeName = "url")]
    [Serializable]
    public class SitemapUrl
    {
        private DateTime lastModified;



        [XmlElement(ElementName = "loc")]
        public string Location { get; set; }

        [XmlElement(ElementName = "lastmod")]
        public string LastModified
        {
            get
            {
                if (DateTime.MinValue.Equals(this.lastModified))
                {
                    this.lastModified = DateTime.Now;
                }

                return this.lastModified.ToString("yyyy-MM-dd");
            }
            set { this.lastModified = DateTime.Parse(value); }
        }

        [XmlElement(ElementName = "changefreq")]
        public ChangeFrequency ChangeFrequency { get; set; }

        [XmlElement(ElementName = "priority")]
        public double Priority { get; set; }


    }


    public enum ChangeFrequency
    {
        always,
        hourly,
        daily,
        weekly,
        monthly,
        yearly,
        never
    }

/// <summary>
        ///   站点地图
        /// </summary>
        /// <param name="pageIndex"> 页面索引</param>
        /// <param name="subjectID"> 科目 </param>
        /// <returns></returns>

        public ActionResult Index(int subjectID = 0, int pageIndex = 1)
        {
            int total = 0;
            int pageSize=2000;
            var list = GetExamList(subjectID, pageIndex, pageSize,ref total);
            Sitemap site = new Sitemap();
            var time= DateTime.Now.ToLongDateString() ;
            
            foreach (var p in list)
            {
                site.Add(new SitemapUrl()
                {
                    ChangeFrequency = ChangeFrequency.weekly,
                    LastModified = time,
                    Location = string.Format("http://rhythmk/home/view/{0}?t={1}", p.ExaminationID , p.ExaminationTitle),
                    Priority = 0.7
                });
            }

            return new SitemapResult(site);

        }

/// <summary>
        /// 判断是否为搜索引擎访问
        /// </summary>
        /// <param name="useragent"></param>
        /// <returns></returns>
        public static bool IsSearchEngine(string useragent)
        {
            bool engine = false;
            if (!string.IsNullOrEmpty(useragent))
            {
                var SpiderKey = System.Configuration.ConfigurationManager.AppSettings["SpiderKey"].ToString();
                // spiderkey=@"Googlebot|Feedfetcher-Google|Baiduspider|Yahoo\s*\!\s*Slurp|YodaoBot|Sosoimagespider|Sosospider|Sogou\s*Web\s*Sprider"
                System.Text.RegularExpressions.Regex rx = new System.Text.RegularExpressions.Regex(SpiderKey, RegexOptions.IgnoreCase | RegexOptions.Compiled);
                engine = rx.IsMatch(useragent);
            }
            return engine;
        }

           public  ActionResult View()
           {
           
           bool engine = IsSearchEngine( this.HttpContext.Request.ServerVariables["Http_User_Agent"]);
            
             // 判断是否为搜索引擎 然后使用不同的试图呈现数据 
            if (engine)
            {
               
                return View("SearchView", entity);
            }
            else
            {
                return View(entity);
            }
            }

static class MyHandler extends Handler {
        // WeakReference to the outer class''s instance.
        private WeakReference<myactivity> mOuter;
 
        public MyHandler(MyActivity activity) {
            mOuter = new WeakReference<myactivity>(activity);
        }
 
        @Override
        public void handleMessage(Message msg) {
            MyActivity outer = mOuter.get();
            if (outer != null) {
                // Do something with outer as your wish.
            }
        }
    }

Android Handler leak 分析及解决办法

3、Inefficient layout weight

4、Memory allocations within drawing code

这是最终在我的机器上修复它的解决方案：我将解决方案移到了不同​​的文件夹。 HUH???如何我问，这能不能解决这个问题。经过一番折腾，我终于找到了根本原因：路径中有一个分号。是的。就我而言，我一直将解决方案存储在名为“H:\\Repo (R;)”的目录中。事实证明，即使 Windows 操作系统允许使用 ; 字符，.NET CLR 根本不喜欢它，也不知道如何处理它。因此它会生成无用的错误消息。

试试看。重命名“这应该可以工作”解决方案的文件夹以删除分号，关闭并重新打开 VS 中的解决方案，按 F5 并观察它运行。或者转到工作解决方案并将文件夹重命名为包含分号，然后观察它是否会破坏 CLR。​​

我很好奇文件夹名称中的任何其他特殊字符是否会导致问题，所以我检查了所有这些字符（在文件夹上，而不是文件名上，但我希望文件名也有类似的结果）。这是我的详尽测试：

Windows 不允许在文件夹名称中使用这些：

\\/:*?"<>|

当路径包含以下任何特殊字符时，解决方案将加载并运行：

`~-_+='',.()[]{}!@#$%&

但是，在 Windows 允许的路径中包含这些字符中的任何一个都会导致 CLR 或 Visual Studio 中的问题：

; 导致“HTTP 错误 500.30 - ASP.NET Core 应用程序无法启动”

^ VS 无法加载解决方案并显示如下错误消息：

"在命令行中指定了以下文件：<.sln> 找不到这些文件，也不会加载这些文件。” 而是加载了一个完全空的 VS 实例。

我还尝试在 VS 中在名称中包含分号的文件夹下创建一个新的“hello world”控制台应用程序，你猜怎么着？这也无法运行。虽然在这种情况下，显然 IIS 没有 HTTP 错误。相反，它说

“未能创建 CoreCLR，HRESULT：0x80070057”

并抛出进程退出代码。再一次，这是路径中有分号的结果，因为从路径中删除该分号并在 VS 中重新加载解决方案可以使其正确运行。所以分号问题似乎源于CLR，因此与IIS无关。

以下是一些有关根本原因的相关帖子，这对于在 IIS Express 上运行的 Web 应用程序并不明显：

Failed to create CoreCLR,HRESULT: 0x80070057

https://github.com/dotnet/sdk/issues/13954

因此，感谢那些对 RCA 非常有帮助的帖子的作者。

有人会认为操作系统允许的特殊字符也可以用于 Visual Studio 代码的路径中。那好吧。吸取的教训。

RouteTable 是一个全局路由表, 它的 Routes 静态属性是一个 RouteCollection 类型的实例,而 RouteCollection 是一个继承自 Collection<RouteBase> 的子类, RouteBase 是 ASP.NET 路由系统定义的基类

.

RouteBase 有一个唯一的实现类:

当我们通过如下方法注册一个路由时:

实际是向全局路由表中添加了一个 Route 类型的实例,部分源码如下: 

public static Route MapRoute(this RouteCollection routes, string name, string url, object defaults, object constraints, string[] namespaces)
    {
      ......
      Route route = new Route(url, (IRouteHandler) new MvcRouteHandler())
      {
　　　　......
      };
　　　 ......
      routes.Add(name, (RouteBase) route);
      return route; }

从源码中我们可以看到,添加 Route 对象的时候,直接传入了一个 MvcRouteHandler 类型的实例.

我们知道, ASP.NET 的路由系统对路由的解析是通过一个注册的 HttpModule 对象实现对请求的拦截,然后为当前 Http 上下文动态映射一个 HttpHandler 对象, 而这个  HttpHandler 对象会接管对当前请求的处理并最终对请求予以响应.

这个注册的 HttpModule 对象的类型叫做 UrlRoutingModule .

我们可以在ASP.NET 的全局系统配置文件中找到它:

　　　　 <httpModules>
　　　　　　　　......
            <add name="UrlRoutingModule-4.0" type="System.Web.Routing.UrlRoutingModule"/>
       　　　　......
        </httpModules>

该类型在 PostResolveRequestCache 事件实现对请求的拦截:

 在拦截时,它做了这么几件事(部分源码省略):

public virtual void PostResolveRequestCache(HttpContextBase context)
    {
      RouteData routeData = this.RouteCollection.GetRouteData(context);     
      IRouteHandler routeHandler = routeData.RouteHandler; IHttpHandler httpHandler = routeHandler.GetHttpHandler(requestContext);  context.RemapHandler(httpHandler); }

1.遍历所有注册的路由,也就是所有添加到全局路由表中的 Route 类型的实例,通过调用它们的 GetRouteData 方法,拿到第一个匹配的 RouteData (路由数据);

2.拿到路由数据中的 RouteHandler 对象, 其实就是 MvcRouteHandler 类型的实例;

3.调用 MvcRouteHandler 的 GetHttpHandler 方法,拿到 HttpHandler.

MvcRouteHandler 的 GetHttpHandler 方法源码如下:

protected virtual IHttpHandler GetHttpHandler(RequestContext requestContext)
    {
      requestContext.HttpContext.SetSessionStateBehavior(this.GetSessionStateBehavior(requestContext));
      return (IHttpHandler) new MvcHandler(requestContext);
    }

可以看到,直接 new 了一个 MvcHandler 类型的实例,

最终,请求转交给这个 MvcHandler 类型的实例处理.

ASP.NET Web API 是怎么与 ASP.NET 路由系统接轨的呢?

我们知道, ASP.NET 的路由系统对路由的解析是通过一个注册的 HttpModule 对象实现对请求的拦截,然后为当前 Http 上下文动态映射一个 HttpHandler 对象, 而这个  HttpHandler 对象会接管对当前请求的处理并最终对请求予以响应.

这一条不仅对 MVC 适用, 对 Web API 同样适用,因为他俩都是借助于 ASP.NET 的路由系统.

区别在于 HttpHandler 的类型不一样而已.

ASP.NET Web API 注册路由的代码通常是这样的:

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new
                {
                    id = RouteParameter.Optional } );

config.Routes 是一个 HttpRouteCollection 类型的实例,并且是只读的.

只读的,就意味着只能在该实例所属的类的构造函数中初始化.

我们知道,这个 config 是 HttpConfiguration 类型,它在 GlobalConfiguration 类中初始化.

在它的初始化代码中,我们可以看到:

private static Lazy<HttpConfiguration> CreateConfiguration()
        {
            return new Lazy<HttpConfiguration>(() =>
            {
                HttpConfiguration config = new HttpConfiguration(new HostedHttpRouteCollection(RouteTable.Routes));
　　　　　　　　　　......return config;
            });
        }

HttpConfiguration 实际是对 HostedHttpRouteCollection 的封装,而后者是对 RouteTable.Route 的封装. 即 ASP.NET 全局路由表的封装.

所以说, HttpConfiguration 类型封装了 ASP.NET 的全局路由表. 它的 Routes 属性的实际类型是  HostedHttpRouteCollection

我们再回头看 config.Routes.MapHttpRoute 方法 , 也就是 HostedHttpRouteCollection 类型的 MapHttpRoute 方法:

public static IHttpRoute MapHttpRoute(this HttpRouteCollection routes, string name, string routeTemplate, object defaults, object constraints, HttpMessageHandler handler)
        {
            ......
            IHttpRoute route = routes.CreateRoute(routeTemplate, defaultsDictionary, constraintsDictionary, dataTokens: null, handler: handler);
            routes.Add(name, route);
            return route;
        }

很简单,创建了一个路由,然后添加它.

我们继续查看 HostedHttpRouteCollection 类型的 CreateRoute 方法:

public override IHttpRoute CreateRoute(string uriTemplate, IDictionary<string, object> defaults, IDictionary<string, object> constraints, IDictionary<string, object> dataTokens, HttpMessageHandler handler)
    {
　　　　......
　　　　return (IHttpRoute) new HostedHttpRoute(uriTemplate, defaults, constraints, dataTokens, handler);
    }

返回了一个 HostedHttpRoute 类型的实例.

我们可以把这个方法 和 上面 MVC 的 MapRoute 方法做比较:

MVC:

public static Route MapRoute(this RouteCollection routes, string name, string url, object defaults, object constraints, string[] namespaces)
    {
      ......
      Route route = new Route(url, (IRouteHandler) new MvcRouteHandler())
      {
　　　　......
      };
　　　 ......
      routes.Add(name, (RouteBase) route);
      return route;
    }

是不是非常像!不同的只是 MVC  new 的路由对象是 Route 类型,而 Web API new 的路由对象是 HostedHttpRoute 类型.

讲到这里,其实 ASP.NET Web API 的路由系统还没有和 ASP.NET 的路由系统衔接起来,它们二者的关系仅仅体现在下面这句话:

HttpConfiguration 实际是对 HostedHttpRouteCollection 的封装,而后者是对 RouteTable.Route 的封装. 即 ASP.NET 全局路由表的封装.

但是,当 HostedHttpRoute 创建后,调用 HostedHttpRouteCollection 的 Add 方法添加时,衔接就真正开始了:

public override void Add(string name, IHttpRoute route)
        {
            _routeCollection.Add(name, route.ToRoute());
        }

 _routeCollection 是 RouteCollection 类型,没看错,就是 ASP.NET 路由系统的 RouteCollection .

所以,这句代码实际是向 ASP.NET 路由系统的路由集合中添加路由,目的就是为了让 UrlRoutingModule 能够拦截到匹配了 Web API 注册的路由的请求.

但是,问题来了,从上面 MVC 的讲解中我们知道, ASP.NET 路由系统的 RouteCollection 是一个继承自 Collection<RouteBase> 的子类, RouteBase 是 ASP.NET 路由的基类,

而 HostedHttpRoute 是实现了 IHttpRoute 接口的实例, 

IHttpRoute  和 RouteBase 风马牛不相接啊!

所以,添加时,Web API 通过 HostedHttpRoute  的 ToRoute 方法,将自己转成了 RouteBase 类型!!

这个转化非常简单:

public static Route ToRoute(this IHttpRoute httpRoute)
        {
　　　　　　　......
            HostedHttpRoute hostedHttpRoute = httpRoute as HostedHttpRoute;
            if (hostedHttpRoute != null)
            {
                return hostedHttpRoute.OriginalRoute; }
　　　　　　 ...... }

问题又来了, HostedHttpRoute 类型的 OriginalRoute 是个什么鬼?当然,肯定是个 Route  类型,也就是说,它是一个 ASP.NET 路由系统定义的 Route 类型.那它是怎么来的呢?

我们知道,在 Web API 注册路由时, MapHttpRoute 内部创建了一个 HostedHttpRoute 类型的实例,并且是直接 new 的.

那么我们去看看 HostedHttpRoute 的构造函数:

public HostedHttpRoute(string uriTemplate, IDictionary<string, object> defaults, IDictionary<string, object> constraints, IDictionary<string, object> dataTokens, HttpMessageHandler handler)
        {
            ......
            OriginalRoute = new HttpWebRoute(uriTemplate, routeDefaults, routeConstraints, routeDataTokens, HttpControllerRouteHandler.Instance, this);
            ......
        }

OriginalRoute 原来是一个 HttpWebRoute 类型,而 HttpWebRoute 则是 ASP.NET 路由系统定义的 Route 类型的子类.

并且,创建 HttpWebRoute 类型的实例时,传入了一个 ASP.NET 路由系统定义的 IRouteHandler 类型的实例 : HttpControllerRouteHandler.Instance

而 HttpControllerRouteHandler 的 GetHttpHandler 方法如下:

/// <summary>
        /// Provides the object that processes the request.
        /// </summary>
        /// <param name="requestContext">An object that encapsulates information about the request.</param>
        /// <returns>
        /// An object that processes the request.
        /// </returns>
        protected virtual IHttpHandler GetHttpHandler(RequestContext requestContext)
        {
            return new HttpControllerHandler(requestContext.RouteData);
        }

返回了一个 HttpControllerHandler 类型的实例.

HttpControllerHandler 类型的XML注释则非常清晰的解释了它的作用:

  /// 用于将 ASP.NET 请求传递给管道并写回结果。</summary>

这里说的管道,自然就是 Web API 的消息处理管道了.

总结:

ASP.NET MVC 和 ASP.NET Web API 都是通过 UrlRoutingModule ,在 PostResolveRequestCache 事件实现对请求的拦截.

拦截后,通过对HTTP上下文,路由等一系列处理后,

MVC 创建了 MvcHandler 进行具体的请求处理及响应;

Web API 创建了 HttpControllerHandler 进行具体的请求处理及响应.