C# RouteCollection.GetWriteLock方法代码示例

        private static void Register(RouteCollection routes, IEnumerable<RouteItem> routeItems)
        {
            using (var @lock = routes.GetWriteLock())
              {
            routes.Clear();

            foreach (var routeItem in routeItems.Where(r => !r.Disabled))
            {
              routes.Add(routeItem.Name, new RouteAdapter(routeItem));
            }
              }
        }

        /// <summary>
        /// Register all routes defined in the RouteMappingConfiguration
        /// </summary>
        /// <param name="routes">RouteCollection to add routes</param>
        /// <param name="config">Routes to register</param>
        public static void RegisterRoutes(RouteCollection routes, RouteMappingConfiguration config)
        {
            if (config == null)
            {
                throw new NullReferenceException("Route mapping configuration not defined.");
            }
            using (routes.GetWriteLock())
            {
                foreach (RouteElement ignoreItem in config.IgnoreRoutes)
                {
                    routes.IgnoreRoute(ignoreItem.Url);
                }

                foreach (RouteElement item in config.Routes)
                {
                    var lowerCaseOnly = item.LowerCaseOnly == null ? config.Routes.LowerCaseOnly : item.LowerCaseOnly.Value;

                    var route = new StrictRoute(item.Url, new MvcRouteHandler(), lowerCaseOnly);
                    route.Defaults = new RouteValueDictionary();
                    route.Defaults.Add("Controller", item.Controller);
                    route.Defaults.Add("Action", item.Action);
                    if (item.Defaults != null)
                    {
                        foreach (string key in item.Defaults.AllKeys)
                        {
                            route.Defaults.Add(key, item.Defaults[key].Value);
                        }
                    }
                    if (item.Constraints != null)
                    {
                        route.Constraints = new RouteValueDictionary();
                        foreach (string key in item.Constraints.AllKeys)
                        {
                            route.Constraints.Add(key, new RegexConstraint(item.Constraints[key].Value));
                        }
                    }
                    if (item.Namespace != null)
                    {
                        if (route.DataTokens == null)
                        {
                            route.DataTokens = new RouteValueDictionary();
                        }
                        route.DataTokens["Namespaces"] = new string[] { item.Namespace };

                    }
                    routes.Add(route);
                }
            }
        }

        public static void MapRoutes(RouteCollection routes, ContextualPublishedCache umbracoCache)
        {
            //find all articulate root nodes
            var articulateNodes = umbracoCache.GetByXPath("//Articulate").ToArray();

            //NOTE: need to write lock because this might need to be remapped while the app is running if
            // any articulate nodes are updated with new values
            using (routes.GetWriteLock())
            {
                //clear the existing articulate routes (if any)
                RemoveExisting(routes);

                // For each articulate root, we need to create some custom route, BUT routes can overlap
                // based on multi-tenency so we need to deal with that.
                // For example a root articulate node might yield a route like:
                //      /
                // and another articulate root node that has a domain might have this url:
                //      http://mydomain/
                // but when that is processed through RoutePathFromNodeUrl, it becomes:
                //      /
                // which already exists and is already assigned to a specific node ID.
                // So what we need to do in these cases is use a special route handler that takes
                // into account the domain assigned to the route.
                var groups = articulateNodes
                    .GroupBy(x => RouteCollectionExtensions.RoutePathFromNodeUrl(x.Url))
                    //This is required to ensure that we create routes that are more specific first
                    // before creating routes that are less specific
                    .OrderByDescending(x => x.Key.Split('/').Length);
                foreach (var grouping in groups)
                {
                    var nodesAsArray = grouping.ToArray();

                    MapRssRoute(routes, grouping.Key, nodesAsArray);
                    MapSearchRoute(routes, grouping.Key, nodesAsArray);
                    MapTagsAndCategoriesRoute(routes, grouping.Key, nodesAsArray);
                    MapMarkdownEditorRoute(routes, grouping.Key, nodesAsArray);

                    foreach (var content in grouping)
                    {
                        MapMetaWeblogRoute(routes, grouping.Key, content);
                        MapManifestRoute(routes, grouping.Key, content);
                        MapRsdRoute(routes, grouping.Key, content);
                    }

                }
            }
        }

        public static void RegisterRoutes(RouteCollection routes)
        {
            using (routes.GetWriteLock())
            {
                routes.Insert(
                    0,
                    new Route(
                        CacheTagMvcSettings.RouteUrl,
                        new RouteValueDictionary(new {controller = "CacheTag", action = "Resource"}),
                        new MvcRouteHandler()
                        )
                    );

                routes.Insert(
                    0,
                    new Route(
                        CacheTagMvcSettings.RouteUrl + ".{ext}",
                        new RouteValueDictionary(new { controller = "CacheTag", action = "Resource", ext = UrlParameter.Optional }),
                        new MvcRouteHandler()
                        )
                    );
            }
        }

        public static void MapRoutes(RouteCollection routes, ContextualPublishedCache umbracoCache)
        {
            //find all Dialogue forum root nodes - Testing adding new line
            var dialogueNodes = umbracoCache.GetByXPath(string.Concat("//", AppConstants.DocTypeForumRoot)).ToArray();
           

            //NOTE: need to write lock because this might need to be remapped while the app is running if
            // any articulate nodes are updated with new values
            using (routes.GetWriteLock())
            {
                //clear the existing articulate routes (if any)
                RemoveExisting(routes);

                // For each articulate root, we need to create some custom route, BUT routes can overlap
                // based on multi-tenency so we need to deal with that. 
                // For example a root articulate node might yield a route like:
                //      /
                // and another articulate root node that has a domain might have this url:
                //      http://mydomain/
                // but when that is processed through RoutePathFromNodeUrl, it becomes:
                //      /
                // which already exists and is already assigned to a specific node ID.
                // So what we need to do in these cases is use a special route handler that takes
                // into account the domain assigned to the route.
                var groups = dialogueNodes.GroupBy(x => RouteCollectionExtensions.RoutePathFromNodeUrl(x.Url));
                foreach (var grouping in groups)
                {
                    var nodesAsArray = grouping.ToArray();

                    MapTopicRoute(routes, grouping.Key, nodesAsArray);
                    MapDialoguePages(routes, grouping.Key, nodesAsArray);
                    MapMemberRoute(routes, grouping.Key, nodesAsArray);
                }
            }

        }