asp.net-mvc asp.net - MVC에서 기본 경로(영역에)설정하는 방법




iis (12)

좋아, 이전에 물어 보았지만 거기에는 확실한 해결책이 없다. 그래서 나 자신과 다른 사람들이 이것을 유용하게 쓸 수있는 목적을 위해.

MVC2 (ASP.NET)에서 누군가가 웹 사이트를 탐색 할 때 기본 영역이 지정되기를 원합니다. 따라서 내 사이트로 이동하면 AreaZ의 ControllerX ActionY로 이동하게됩니다.

Global.asax에서 다음 경로 사용

routes.MapRoute(
                "Area",
                "",
                new { area = "AreaZ", controller = "ControllerX ", action = "ActionY " }
            );

이제는 올바른 페이지를 제공하려고 시도하는 것처럼 작동합니다. 그러나 MVC는 영역 폴더가 아니라 사이트의 루트에서보기를 찾습니다.

이 문제를 해결할 방법이 있습니까?

편집하다

'Solution'이 있으며 ControllerX에 있으며, ActionY는 뷰의 전체 경로를 반환합니다. 해킹 비트이지만 작동합니다. 그러나 나는 더 나은 해결책이 있기를 바라고 있습니다.

         public ActionResult ActionY()
        {
            return View("~/Areas/AreaZ/views/ActionY.aspx");
        }

편집하다:

이것은 또한 페이지의 HTML ActionLink가있을 때 문제가됩니다. 영역이 설정되어 있지 않으면 작업 링크가 공백으로 출력됩니다.

이 모든 것이 설계 상 또는 결함인가?


Answers

먼저 MVC2의 어떤 버전을 사용하고 있습니까? preview2에서 RC 로의 중요한 변경 사항이 있습니다.

RC를 사용한다고 가정하면 경로 매핑이 다르게 보일 것입니다. 해당 지역의 AreaRegistration.cs 에서 기본 경로를 등록 할 수 있습니다. 예 :

        context.MapRoute(
            "ShopArea_default",
            "{controller}/{action}/{id}",
            new { action = "Index", id = "", controller="MyRoute" }
        );

위 코드는 사용자를 MyRouteControllerShopArea 로 기본값으로 ShopArea .

컨트롤러를 지정해야하므로 빈 문자열을 두 번째 매개 변수로 사용하면 예외가 발생합니다.

물론 Global.asax 에서 기본 경로를 변경해야합니다 (예 : 기본 사이트의 접두어 사용).

또한이 스레드와 Haack의 답변을 참조하십시오 : MVC 2 AreaRegistration Routes Order

희망이 도움이됩니다.


글쎄, 사용자 정의보기 엔진을 만들 때이 작업을 수행 할 수 있지만 여전히 대안을 가질 수 있습니다.

  • 기본적으로 표시 할 내용을 결정하십시오.
  • 그 무언가는 컨트롤러와 액션 (그리고 Area)을 가지고 있습니다, 맞습니까?
  • 해당 Area 등록을 열고 다음과 같이 추가하십시오 :
public override void RegisterArea(AreaRegistrationContext context)
{
    //this makes it work for the empty url (just domain) to act as current Area.
    context.MapRoute(
        "Area_empty",
        "",
        new { controller = "Home", action = "Index", id = UrlParameter.Optional },
        namespaces: new string[] { "Area controller namespace" }
    );
        //other routes of the area
}

건배!


이 질문에 대한 받아 들여진 해결책은 사용자 정의보기 엔진을 작성하는 방법을 요약하는 동안 올바른 질문에 대답하지 않는 것입니다. 여기서 문제는 피노가 자신의 기본 경로를 잘못 지정하고 있다는 것입니다. 특히 그의 "영역"정의가 올바르지 않습니다. "Area"는 DataTokens 컬렉션을 통해 확인되며 다음과 같이 추가되어야합니다.

var defaultRoute = new Route("",new RouteValueDictionary(){{"controller","Default"},{"action","Index"}},null/*constraints*/,new RouteValueDictionary(){{"area","Admin"}},new MvcRouteHandler());
defaultRoute.DataTokens.Add("Namespaces","MyProject.Web.Admin.Controller"); 
routes.Add(defaultRoute);

defaults 객체에 지정된 "영역"은 무시 됩니다. 위의 코드는 사이트의 루트에 대한 요청을 포착 한 다음 기본 영역 인 관리 영역의 색인 동작을 호출하는 기본 경로를 만듭니다. DataTokens에 "네임 스페이스"키가 추가된다는 점에 유의하십시오. 동일한 이름을 가진 컨트롤러가 여러 개있는 경우에만 필요합니다. 이 솔루션은 Mvc2 및 Mvc3 .NET 3.5 / 4.0에서 검증되었습니다.


routes.MapRoute(
                "Area",
                "{area}/",
                new { area = "AreaZ", controller = "ControlerX ", action = "ActionY " }
            );

너 그거 해봤 니?


이 사람은 나에게 관심이 있었고 마침내 그것에 대해 조사 할 기회가있었습니다. 다른 사람들은 이것이 라우팅 자체에 대한 문제가 아니라 보기찾는 문제라는 것을 분명히 이해하지 못했습니다. 이는 질문 제목이 라우팅에 관한 것임을 나타 내기 때문일 것입니다.

어떤 경우이든 뷰 관련 문제이기 때문에 원하는 것을 얻는 유일한 방법 은 기본 뷰 엔진재정의하는 것 입니다. 일반적으로이 작업을 수행 할 때보기 엔진 (즉, Spark, NHaml 등)을 전환하는 것이 목적입니다. 이 경우, 오버 라이딩해야하는 뷰 생성 로직이 아니라 VirtualPathProviderViewEngine 클래스의 FindPartialViewFindView 메소드입니다.

VirtualPathProviderViewEngine 다른 모든 요소는 액세스 할 수 없기 때문에 행운의 별에 감사 할 수 있습니다. 개인 정보이므로 찾기 논리를 재정의하는 것이 매우 귀찮습니다. 기본적으로 코드의 절반을 다시 작성해야하기 때문입니다. 위치 캐시 및 위치 형식으로 멋지게 재생하려면 이미 작성된 것입니다. Reflector를 파고 들자 마침내 작동하는 솔루션을 찾았습니다.

제가 여기서 한 것은 AreaAwareViewEngine 대신 VirtualPathProviderViewEngine 에서 직접 파생 된 추상 AreaAwareViewEngine 을 만드는 것입니다. Spark 뷰를 (또는 무엇이든) 만들려는 경우이 클래스를 기본 유형으로 사용할 수 있도록이 작업을 수행했습니다.

아래의 코드는 꽤 오래 지속되어 실제로 수행되는 작업에 대한 간단한 요약을 제공합니다. {2} 를 지역 이름에 해당하는 위치 형식으로 {1} 과 동일한 방식으로 넣을 수 있습니다. 컨트롤러 이름 그게 다야! 이것이이 코드를 작성해야하는 이유입니다.

BaseAreaAwareViewEngine.cs

public abstract class BaseAreaAwareViewEngine : VirtualPathProviderViewEngine
{
    private static readonly string[] EmptyLocations = { };

    public override ViewEngineResult FindView(
        ControllerContext controllerContext, string viewName,
        string masterName, bool useCache)
    {
        if (controllerContext == null)
        {
            throw new ArgumentNullException("controllerContext");
        }
        if (string.IsNullOrEmpty(viewName))
        {
            throw new ArgumentNullException(viewName,
                "Value cannot be null or empty.");
        }

        string area = getArea(controllerContext);
        return FindAreaView(controllerContext, area, viewName,
            masterName, useCache);
    }

    public override ViewEngineResult FindPartialView(
        ControllerContext controllerContext, string partialViewName,
        bool useCache)
    {
        if (controllerContext == null)
        {
            throw new ArgumentNullException("controllerContext");
        }
        if (string.IsNullOrEmpty(partialViewName))
        {
            throw new ArgumentNullException(partialViewName,
                "Value cannot be null or empty.");
        }

        string area = getArea(controllerContext);
        return FindAreaPartialView(controllerContext, area,
            partialViewName, useCache);
    }

    protected virtual ViewEngineResult FindAreaView(
        ControllerContext controllerContext, string areaName, string viewName,
        string masterName, bool useCache)
    {
        string controllerName =
            controllerContext.RouteData.GetRequiredString("controller");
        string[] searchedViewPaths;
        string viewPath = GetPath(controllerContext, ViewLocationFormats,
            "ViewLocationFormats", viewName, controllerName, areaName, "View",
            useCache, out searchedViewPaths);
        string[] searchedMasterPaths;
        string masterPath = GetPath(controllerContext, MasterLocationFormats,
            "MasterLocationFormats", masterName, controllerName, areaName,
            "Master", useCache, out searchedMasterPaths);
        if (!string.IsNullOrEmpty(viewPath) &&
            (!string.IsNullOrEmpty(masterPath) || 
              string.IsNullOrEmpty(masterName)))
        {
            return new ViewEngineResult(CreateView(controllerContext, viewPath,
                masterPath), this);
        }
        return new ViewEngineResult(
            searchedViewPaths.Union<string>(searchedMasterPaths));
    }

    protected virtual ViewEngineResult FindAreaPartialView(
        ControllerContext controllerContext, string areaName,
        string viewName, bool useCache)
    {
        string controllerName =
            controllerContext.RouteData.GetRequiredString("controller");
        string[] searchedViewPaths;
        string partialViewPath = GetPath(controllerContext,
            ViewLocationFormats, "PartialViewLocationFormats", viewName,
            controllerName, areaName, "Partial", useCache,
            out searchedViewPaths);
        if (!string.IsNullOrEmpty(partialViewPath))
        {
            return new ViewEngineResult(CreatePartialView(controllerContext,
                partialViewPath), this);
        }
        return new ViewEngineResult(searchedViewPaths);
    }

    protected string CreateCacheKey(string prefix, string name,
        string controller, string area)
    {
        return string.Format(CultureInfo.InvariantCulture,
            ":ViewCacheEntry:{0}:{1}:{2}:{3}:{4}:",
            base.GetType().AssemblyQualifiedName,
            prefix, name, controller, area);
    }

    protected string GetPath(ControllerContext controllerContext,
        string[] locations, string locationsPropertyName, string name,
        string controllerName, string areaName, string cacheKeyPrefix,
        bool useCache, out string[] searchedLocations)
    {
        searchedLocations = EmptyLocations;
        if (string.IsNullOrEmpty(name))
        {
            return string.Empty;
        }
        if ((locations == null) || (locations.Length == 0))
        {
            throw new InvalidOperationException(string.Format("The property " +
                "'{0}' cannot be null or empty.", locationsPropertyName));
        }
        bool isSpecificPath = IsSpecificPath(name);
        string key = CreateCacheKey(cacheKeyPrefix, name,
            isSpecificPath ? string.Empty : controllerName,
            isSpecificPath ? string.Empty : areaName);
        if (useCache)
        {
            string viewLocation = ViewLocationCache.GetViewLocation(
                controllerContext.HttpContext, key);
            if (viewLocation != null)
            {
                return viewLocation;
            }
        }
        if (!isSpecificPath)
        {
            return GetPathFromGeneralName(controllerContext, locations, name,
                controllerName, areaName, key, ref searchedLocations);
        }
        return GetPathFromSpecificName(controllerContext, name, key,
            ref searchedLocations);
    }

    protected string GetPathFromGeneralName(ControllerContext controllerContext,
        string[] locations, string name, string controllerName,
        string areaName, string cacheKey, ref string[] searchedLocations)
    {
        string virtualPath = string.Empty;
        searchedLocations = new string[locations.Length];
        for (int i = 0; i < locations.Length; i++)
        {
            if (string.IsNullOrEmpty(areaName) && locations[i].Contains("{2}"))
            {
                continue;
            }
            string testPath = string.Format(CultureInfo.InvariantCulture,
                locations[i], name, controllerName, areaName);
            if (FileExists(controllerContext, testPath))
            {
                searchedLocations = EmptyLocations;
                virtualPath = testPath;
                ViewLocationCache.InsertViewLocation(
                    controllerContext.HttpContext, cacheKey, virtualPath);
                return virtualPath;
            }
            searchedLocations[i] = testPath;
        }
        return virtualPath;
    }

    protected string GetPathFromSpecificName(
        ControllerContext controllerContext, string name, string cacheKey,
        ref string[] searchedLocations)
    {
        string virtualPath = name;
        if (!FileExists(controllerContext, name))
        {
            virtualPath = string.Empty;
            searchedLocations = new string[] { name };
        }
        ViewLocationCache.InsertViewLocation(controllerContext.HttpContext,
            cacheKey, virtualPath);
        return virtualPath;
    }


    protected string getArea(ControllerContext controllerContext)
    {
        // First try to get area from a RouteValue override, like one specified in the Defaults arg to a Route.
        object areaO;
        controllerContext.RouteData.Values.TryGetValue("area", out areaO);

        // If not specified, try to get it from the Controller's namespace
        if (areaO != null)
            return (string)areaO;

        string namespa = controllerContext.Controller.GetType().Namespace;
        int areaStart = namespa.IndexOf("Areas.");
        if (areaStart == -1)
            return null;

        areaStart += 6;
        int areaEnd = namespa.IndexOf('.', areaStart + 1);
        string area = namespa.Substring(areaStart, areaEnd - areaStart);
        return area;
    }

    protected static bool IsSpecificPath(string name)
    {
        char ch = name[0];
        if (ch != '~')
        {
            return (ch == '/');
        }
        return true;
    }
}

이제 명시된 바와 같이, 이것은 구체적인 엔진이 아니므로이를 생성해야합니다. 다행히도이 부분은 훨씬 쉽습니다. 기본 형식을 설정하고 실제로보기를 만드는 것뿐입니다.

AreaAwareViewEngine.cs

public class AreaAwareViewEngine : BaseAreaAwareViewEngine
{
    public AreaAwareViewEngine()
    {
        MasterLocationFormats = new string[]
        {
            "~/Areas/{2}/Views/{1}/{0}.master",
            "~/Areas/{2}/Views/{1}/{0}.cshtml",
            "~/Areas/{2}/Views/Shared/{0}.master",
            "~/Areas/{2}/Views/Shared/{0}.cshtml",
            "~/Views/{1}/{0}.master",
            "~/Views/{1}/{0}.cshtml",
            "~/Views/Shared/{0}.master"
            "~/Views/Shared/{0}.cshtml"
        };
        ViewLocationFormats = new string[]
        {
            "~/Areas/{2}/Views/{1}/{0}.aspx",
            "~/Areas/{2}/Views/{1}/{0}.ascx",
            "~/Areas/{2}/Views/{1}/{0}.cshtml",
            "~/Areas/{2}/Views/Shared/{0}.aspx",
            "~/Areas/{2}/Views/Shared/{0}.ascx",
            "~/Areas/{2}/Views/Shared/{0}.cshtml",
            "~/Views/{1}/{0}.aspx",
            "~/Views/{1}/{0}.ascx",
            "~/Views/{1}/{0}.cshtml",
            "~/Views/Shared/{0}.aspx"
            "~/Views/Shared/{0}.ascx"
            "~/Views/Shared/{0}.cshtml"
        };
        PartialViewLocationFormats = ViewLocationFormats;
    }

    protected override IView CreatePartialView(
        ControllerContext controllerContext, string partialPath)
    {
        if (partialPath.EndsWith(".cshtml"))
            return new System.Web.Mvc.RazorView(controllerContext, partialPath, null, false, null);
        else
            return new WebFormView(controllerContext, partialPath);
    }

    protected override IView CreateView(ControllerContext controllerContext,
        string viewPath, string masterPath)
    {
        if (viewPath.EndsWith(".cshtml"))
            return new RazorView(controllerContext, viewPath, masterPath, false, null);
        else
            return new WebFormView(controllerContext, viewPath, masterPath);
    }
}

표준 ViewLocationFormats 에 몇 가지 항목을 추가 ViewLocationFormats . 이들은 새로운 {2} 항목이며 {2}RouteData 입력 한 area 매핑됩니다. MasterLocationFormats 혼자두고 MasterLocationFormats , MasterLocationFormats 분명히 변경할 수 있습니다.

이제 global.asax 를 수정하여이 뷰 엔진을 등록하십시오.

Global.asax.cs

protected void Application_Start()
{
    RegisterRoutes(RouteTable.Routes);
    ViewEngines.Engines.Clear();
    ViewEngines.Engines.Add(new AreaAwareViewEngine());
}

... 기본 경로를 등록하십시오.

public static void RegisterRoutes(RouteCollection routes)
{
    routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
    routes.MapRoute(
        "Area",
        "",
        new { area = "AreaZ", controller = "Default", action = "ActionY" }
    );
    routes.MapRoute(
        "Default",
        "{controller}/{action}/{id}",
        new { controller = "Home", action = "Index", id = "" }
    );
}

이제 방금 언급 한 AreaController 만듭니다.

DefaultController.cs ~ ~ / Controllers /)

public class DefaultController : Controller
{
    public ActionResult ActionY()
    {
        return View("TestView");
    }
}

당연히 우리는 디렉토리 구조와 그것과 함께 가기위한 뷰가 필요합니다 - 우리는이 초소형을 간단하게 유지할 것입니다 :

TestView.aspx (~ / Areas / AreaZ / Views / Default / 또는 ~ / Areas / AreaZ / Views / Shared /)

<%@ Page Title="" Language="C#" Inherits="System.Web.Mvc.ViewPage" %>
<h2>TestView</h2>
This is a test view in AreaZ.

그리고 그게 다야. 마침내 끝났습니다 .

대부분의 경우 BaseAreaAwareViewEngineAreaAwareViewEngine 을 가져와 모든 MVC 프로젝트에 드롭 할 수 있어야합니다. BaseAreaAwareViewEngine 작업을 완료하는 데 많은 코드가 필요했지만 한 번만 작성하면됩니다. 그 후에는 global.asax.cs 에서 몇 줄을 편집하고 사이트 구조를 만드는 것만 global.asax.cs 문제가됩니다.


음,이 모든 프로그래밍이 왜 그런지 모르겠다. 원래의 문제는이 기본 경로를 지정함으로써 쉽게 해결된다고 생각한다.

routes.MapRoute("Default", "{*id}", 
                 new { controller = "Home"
                     , action = "Index"
                     , id = UrlParameter.Optional 
                     }
              );

그것은 이미 응답되었습니다 - 이것은 짧은 구문입니다 (ASP.net 3, 4, 5) :

routes.MapRoute("redirect all other requests", "{*url}",
    new {
        controller = "UnderConstruction",
        action = "Index"
        }).DataTokens = new RouteValueDictionary(new { area = "Shop" });

이게 내가 한 일이야. MapRoute ()에서 영역을 설정하는 것을 허용하지 않는 이유를 모르지만 경로 객체를 반환하므로 사용자가 원하는대로 추가 변경을 계속할 수 있습니다. 엔터프라이즈 고객에게 판매되는 모듈 식 MVC 사이트가 있고 새로운 모듈을 추가하기 위해 dll을 bin 폴더에 드롭 할 수 있어야하기 때문에이 방법을 사용합니다. AppSettings 구성에서 "HomeArea"를 변경할 수 있습니다.

var route = routes.MapRoute(
                "Home_Default", 
                "", 
                new {controller = "Home", action = "index" },
                new[] { "IPC.Web.Core.Controllers" }
               );
route.DataTokens["area"] = area;

편집 : 당신은 AreaRegistration.RegisterArea에서 사용자가 기본적으로 가고 싶은 영역에 대해서도 이것을 시도 할 수 있습니다. 나는 그것을 테스트하지 않았지만 AreaRegistrationContext.MapRoute는 route.DataTokens["area"] = this.AreaName; 너를 위해서.

context.MapRoute(
                    "Home_Default", 
                    "", 
                    new {controller = "Home", action = "index" },
                    new[] { "IPC.Web.Core.Controllers" }
                   );

RC에이 설정이 있는지 확실하지 않더라도 다음을 Application_Start에 추가하면 나에게 적합합니다.

var engine = (WebFormViewEngine)ViewEngines.Engines.First();

// These additions allow me to route default requests for "/" to the home area
engine.ViewLocationFormats = new string[] { 
    "~/Views/{1}/{0}.aspx",
    "~/Views/{1}/{0}.ascx",
    "~/Areas/{1}/Views/{1}/{0}.aspx", // new
    "~/Areas/{1}/Views/{1}/{0}.ascx", // new
    "~/Areas/{1}/Views/{0}.aspx", // new
    "~/Areas/{1}/Views/{0}.ascx", // new
    "~/Views/{1}/{0}.ascx",
    "~/Views/Shared/{0}.aspx",
    "~/Views/Shared/{0}.ascx"
};

나는 그가 ~/ URL을 방문한 번 ~/AreaZ URL로 리디렉션되기를 원한다고 생각합니다. 루트 HomeController 내에서 다음 코드를 사용하여 구현할 수 있습니다.

public class HomeController
{
    public ActionResult Index()
    {
        return RedirectToAction("ActionY", "ControllerX", new { Area = "AreaZ" });
    }
}

그리고 Global.asax 의 다음 경로.

routes.MapRoute(
    "Redirection to AreaZ",
    String.Empty,
    new { controller = "Home ", action = "Index" }
);

다른 빌딩 블록의 위치는 요청 수명주기에서 수행됩니다. ASP.NET MVC 요청 수명주기의 첫 번째 단계 중 하나는 요청 된 URL을 올바른 컨트롤러 작업 메서드에 매핑하는 것입니다. 이 프로세스를 라우팅이라고합니다. 기본 경로는 Global.asax 파일에서 초기화되며 요청을 처리하는 방법을 ASP.NET MVC 프레임 워크에 설명합니다. MvcApplication1 프로젝트에서 Global.asax 파일을 두 번 클릭하면 다음 코드가 표시됩니다.

using System; using System.Collections.Generic; using System.Linq; using System.Web; using System.Web.Mvc; using System.Web.Routing;

namespace MvcApplication1 {

   public class GlobalApplication : System.Web.HttpApplication
   {
       public static void RegisterRoutes(RouteCollection routes)
       {
           routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

           routes.MapRoute(
               "Default",                                          // Route name
               "{controller}/{action}/{id}",                       // URL with parameters
               new { controller = "Home", action = "Index",
                     id = "" }  // Parameter defaults
           );

       }

       protected void Application_Start()
       {
           RegisterRoutes(RouteTable.Routes);
       }
   }

}

응용 프로그램이 컴파일되거나 웹 서버가 다시 시작될 때마다 발생하는 Application_Start () 이벤트 핸들러에서 경로 테이블이 등록됩니다. 기본 경로의 이름은 Default이며 http://www.example.com/ {controller} / {action} / {id} 형식의 URL에 응답합니다. {및} 사이의 변수는 요청 URL의 실제 값 또는 URL에 대체가없는 경우 기본값으로 채워집니다. 이 기본 경로는 기본 라우팅 매개 변수에 따라 홈 컨트롤러와 색인 작업 방법에 매핑됩니다. 이 라우팅 맵에서는 다른 작업을 수행하지 않습니다.

기본적으로 가능한 모든 URL은이 기본 경로를 통해 매핑 될 수 있습니다. 우리 자신의 경로를 만들 수도 있습니다. 예를 들어 http://www.example.com/Employee/Maarten URL을 Employee 컨트롤러, Show 액션 및 firstname 매개 변수에 매핑합니다. 다음 코드 스 니펫은 방금 연 Global.asax 파일에 삽입 할 수 있습니다. ASP.NET MVC 프레임 워크는 첫 번째로 일치하는 경로를 사용하므로이 코드 조각은 기본 경로 위에 삽입해야합니다. 그렇지 않으면 경로가 사용되지 않습니다.

routes.MapRoute(

   "EmployeeShow",                    // Route name
   "Employee/{firstname}",            // URL with parameters
    new {                             // Parameter defaults
       controller = "Employee",
       action = "Show", 
       firstname = "" 
   }  

);

이제이 경로에 필요한 구성 요소를 추가해 보겠습니다. 먼저, Controllers 폴더에 EmployeeController라는 클래스를 만듭니다. 프로젝트에 새 항목을 추가하고 웹 | 아래에있는 MVC 컨트롤러 클래스 템플릿을 선택하여이 작업을 수행 할 수 있습니다. MVC 카테고리. 색인 조치 메소드를 제거하고이를 Show라는 메소드 또는 조치로 바꾸십시오. 이 메서드는 firstname 매개 변수를 받아서 ViewData 사전에 데이터를 전달합니다. 이 사전은보기에서 데이터를 표시하는 데 사용됩니다.

EmployeeController 클래스는 Employee 객체를 뷰에 전달합니다. 이 Employee 클래스는 Models 폴더에 추가해야합니다 (이 폴더를 마우스 오른쪽 단추로 클릭 한 다음 컨텍스트 메뉴에서 Add | Class를 선택하십시오). 다음은 Employee 클래스의 코드입니다.

namespace MvcApplication1.Models {

   public class Employee
   {
       public string FirstName { get; set; }
       public string LastName { get; set; }
       public string Email { get; set; }
   }

} 

어쩌면 정수로 열거 형을 사용하려고 시도해야할까요?

이게 내가 한거야.

public enum ECacheType
{
    cache=1, none=2
}

public enum EFileType 
{
    t1=1, t2=2
}

public class TestController
{
    [Route("{type}/{library}/{version}/{file?}/{renew?}")]
    public ActionResult Index2(EFileType type,
                              string library,
                              string version,
                              string file = null,
                              ECacheType renew = ECacheType.cache)
    {
        return View("Index");
    }
}

그리고 내 라우팅 파일

public static void RegisterRoutes(RouteCollection routes)
{
    routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

    // To enable route attribute in controllers
    routes.MapMvcAttributeRoutes();

    routes.MapRoute(
            name: "Default",
            url: "{controller}/{action}/{id}",
            defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional });
}

다음과 같이 전화를 걸 수 있습니다.

http://localhost:52392/2/lib1/ver1/file1/1
http://localhost:52392/2/lib1/ver1/file1
http://localhost:52392/2/lib1/ver1

또는

http://localhost:52392/2/lib1/ver1/file1/1/
http://localhost:52392/2/lib1/ver1/file1/
http://localhost:52392/2/lib1/ver1/

그리고 그것은 잘 작동 ...





asp.net-mvc asp.net-mvc-2