C# IMapper.Root方法代码示例

        public override void Map(IMapper map)
        {
            if (HttpContext.Current != null && HttpContext.Current.IsDebuggingEnabled)
            {
                map.DebugRoute(RouteDiagnosticsVirtualPath);
            }

            map.Root<HomeController>(c => c.Index());

            map.Resources<BragController>(c => c.Only("new", "create"));

            // use the standard restful routes for managing runtime Sessions:
            map.Resource<SessionController>(c => c.Only("create", "new", "destroy"));

            // add human-friendly shortcuts for logging in and out:
            map.Path("login").GetOnly().To<SessionController>(c => c.New());
            map.Path("logout").GetOnly().To<HomeController>(c => c.Logout());

            // add a path to the OUr Services page
            map.Path("ourservice").GetOnly().To<HomeController>(c => c.OurService());
            map.Path("admin").GetOnly().To<HomeController>(c => c.Admin());

            // HACK: add a standard MVC pattern-matching route limited
            //       to the PartialController to support calls like:
            //       Html.RenderAction("login", "partial");
            map.Route(new Route("partial/{action}",
                                new RouteValueDictionary(new {controller = "partial"}),
                                new MvcRouteHandler()));
        }

        public override void Map(IMapper map)
        {
            map.DebugRoute("routedebug");
            map.Root<CommentsController>(c => c.Index(null));
            map.Resources<CommentsController>(c => c.Only("index", "new", "create"));
            map.Resource<ContactController>(c => c.Only("new", "create"));
            map.Resource<ErrorController>(e => e.Only("show"));

            /*
             * Note: You can register and next resources
             *
            map.Root<HomeController>(x => x.Index());

            map.Resources<BlogsController>(blogs =>
            {
                blogs.As("weblogs");
                blogs.Only("index", "show");
                blogs.Collection(x => x.Get("latest"));

                blogs.Resources<PostsController>(posts =>
                {
                    posts.Except("create", "update", "destroy");
                    posts.Resources<CommentsController>(c => c.Except("destroy"));
                });
            });

            map.Area<Controllers.Admin.BlogsController>("admin", admin =>
            {
                admin.Resources<Controllers.Admin.BlogsController>();
                admin.Resources<Controllers.Admin.PostsController>();
            });
             */
        }

        public override void Map(IMapper map)
        {
            map.DebugRoute("routedebug");

            map.Root<CategoryController>(c => c.Index("/"));

            map.Resources<UserController>();

            map.Resources<ReportController>(c => c.Member(x => x.Get("Search")));

            map.Resources<ReportParameterController>(reportParameter => reportParameter.Only("Index"));

            map.Resources<CategoryController>(category => category.Only("Index"));

            map.Resources<ClientController>(client => client.Only("Index"));

            map.Resources<RoleController>(r => r.WithFormatRoutes());

            map.Resource<FileController>(file => file.Only("Create"));

            map.Resource<SearchController>(s => s.Only("New", "Create"));

            map.Resources<AccountController>(
                account =>
                    {
                        account.Except("new", "create", "show", "index", "update", "destroy");
                        account.Collection(x => x.Get("Login"));
                        account.Collection(x => x.Post("Login"));
                        account.Collection(x => x.Get("Register"));
                        account.Collection(x => x.Post("Register"));
                        account.Collection(x => x.Put("Confirm"));
                    });
        }

        public override void Map(IMapper map)
        {
            map.DebugRoute("routedebug");

            map.Root<MoviesController>(r => r.Index());

            map.Resources<MoviesController>(r => r.Except("Show", "Edit", "Update"));
        }

 public override void Map(IMapper map)
 {
     map.DebugRoute("routedebug");
     map.Root<HomeController>(h => h.Index());
     map.Resources<AnimalsController>();
     map.Resources<KeepersController>();
     map.Resources<EnclosuresController>();
 }

        public override void Map(IMapper map)
        {
            map.DebugRoute("routedebug");

            map.Root<HomeController>(x => x.Index());

            map.Resources<PageNewsController>(x => x.Only("Index"));
        }

 public override void Map(IMapper map)
 {
     map.Root<HomeController>(x => x.Index());
     map.Resources<BlogsController>(blogs =>
     {
         blogs.Resources<PostsController>();
     });
     map.Resources<GalleriesController>();
 }

        public override void Map(IMapper map)
        {
            map.Root<RootController>(x => x.Index());

            map.Resources<TodosController>(mapper => {
                // Manually need to add a GET /todos/id/delete route not out-of-the-box
                mapper.Member(action => action.Get("delete"));
                mapper.WithFormatRoutes();
            });
        }

        public override void Map(IMapper map)
        {
            // register the route debugger
            map.DebugRoute("routedebug");
            // register the root of the site
            map.Root<HomeController>(x => x.Index());
            map.Resource<QuickStartController>(quickstart => quickstart.Only("show"));

            // Connecting RouteSets: notice that we are connecting another RouteSet to this one
            map.Connect<OtherRouteSet>();

            // Mapping an area: notice, all these controllers are part of the area
            map.Area<AreasController>("mappings", area =>
            {
                area.Resource<ResourceController>();
                area.Resources<ResourcesController>(resources =>
                {
                    // we are nesting a resource inside of another resource
                    resources.Resources<OtherResourcesController>(other => other.Only("index"));
                    // using collection
                    resources.Collection(r => r.Get("many"));
                    // using member
                    resources.Member(r => r.Get("lonely"));
                });
                area.Resource<AreasController>();
                area.Resource<ExtrasController>(extras =>
                {
                    // renaming the url part
                    extras.As("extras");
                    // using member, notice collection is unavailable
                    extras.Member(e => e.Get("member"));
                    // Use path
                    extras.Path("using_path").To<ExtrasController>(e => e.UsingPath()).GetOnly();
                    // Using route
                    extras.Route(new Route("mappings/extras/with_route", new RouteValueDictionary(new { controller = "extras", action = "usingroute", area = "mappings" }), new MvcRouteHandler()));
                    // Format route action, register like always
                    extras.Member(e => e.Get("awesome"));
                    // enable format routes
                    extras.WithFormatRoutes();
                });
            });

            // Not the route debuger, just a controller
            map.Resource<RouteDebuggerController>(debug => debug.Only("show"));

            // redirects should always be last
            map.Connect<RedirectRouteSet>();
        }

            public override void Map(IMapper map)
            {
                #if DEBUG
                map.DebugRoute("routedebug");
                #endif

                map.Root<HomeController>(x => x.Index());

                map.Resource<HomeController>(home =>
                {
                    home.Only();
                });

                map.Resources<WikiController>(wiki =>
                {
                    wiki.As("wiki");
                    wiki.Only("index", "show");
                });

                map.Resources<TestAgentsController>(agents =>
                {
                    agents.As("agents");
                    agents.Only("index", "show");
                });

                map.Resources<TestProjectsController>(projects =>
                {
                    projects.As("projects");

                    projects.Resources<TestBuildsController>(builds =>
                    {
                        builds.As("builds");
                        builds.Only("index", "new", "create");
                    });

                    projects.Resources<TestPlansController>(plans =>
                    {
                        plans.As("plans");
                    });

                    projects.Resources<TestSessionsController>(sessions =>
                    {
                        sessions.As("sessions");
                        sessions.Member(z => z.Post("restart"));
                        sessions.Member(z => z.Post("continue"));
                    });
                });
            }

 public override void Map(IMapper map)
 {
     // ReSharper disable ConvertToLambdaExpression
     map.Root<HomeController>(x => x.Index());
     map.Resources<PostsController>(posts => {
         posts.Collection(x => {
             x.Get("search");
             x.Post("search");
         });
     });
     map.Resources<AccountsController>(accounts => {
         accounts.As("users");
         accounts.Member(x => x.Post("update"));
     });
     // ReSharper restore ConvertToLambdaExpression
 }

        public override void Map(IMapper map)
        {
            map.Root<RootController>(x => x.Index());
            map.DebugRoute("routedebug");
            map.Area<BlogsController>("", area => area.Resources<BlogsController>(blogs =>
                                                                                      {
                                                                                          blogs.WithFormatRoutes();
                                                                                          blogs.Member(x => x.Get("test"));
                                                                                          blogs.Resources<PostsController>();
                                                                                      }));

            map.Area<Controllers.Admin.BlogsController>("admin", admin =>
                                                                     {
                                                                         admin.Resources<BlogsController>();
                                                                         admin.Resources<PostsController>();
                                                                     });
        }

        public override void Map(IMapper map)
        {
            // Additional delete mapping.
            MapDelete = true;

            map.DebugRoute("routedebug");

            // Mapped the index
            map.Root<HomeController>(x => x.Index());

            // Mapping the resource, but I only want an index.
            // map.Resource<ProductsController>(p => { p.Only("index"); p.As("products"); }); // ERROR and no index in the RouteDebug...

            // Mapping the resource, just give me everything.
            map.Resources<ProductsController>(p => p.As("products")); // NO ERROR, But also no index in the RouteDebug...

            // Created a seperate set.
            map.Connect<AdminRouteSet>();
        }

        public override void Map(IMapper map)
        {
            map.DebugRoute("routedebug");
            map.Root<HomeController>(x => x.Index());

            map.Resources<QuotesController>();
            map.Resources<CategoriesController>();
            map.Resources<AuthorsController>();
            map.Resources<MenusController>();
            map.Resources<UserQuotesController>(uq =>
            {
                uq.As("user-quotes");
                uq.Only("create");
            });
            map.Resources<LiveQuotesController>(l =>
            {
                l.As("live");
                l.Only("index");
            });
        }

        public override void Map(IMapper map)
        {
            map.DebugRoute("routedebug");

            map.Root<HomeController>(x => x.Index());

            map.Resources<UsersController>(users =>
                users.Resources<ShelvesController>()
            );
            map.Resources<ShelvesController>(shelves => {
                shelves.Resources<BooksController>();
                shelves.Resources<UsersController>();
            });
            map.Resources<BooksController>(books => {
                books.Resources<AuthorsController>();
                books.Resources<ShelvesController>();
            });
            map.Resources<AuthorsController>(authors =>
                authors.Resources<BooksController>()
            );
        }