Możliwy błąd z routingiem ASP.NET MVC 3?

Question

Zwykle nie wpisałbym tego tytułu w pytaniu, ale jestem pewien, że to błąd (lub projekt?)

Stworzyłem zupełnie nową aplikację sieci Web ASP.NET MVC 3.

Potem poszedłem na stronę/Strona główna/Informacje.

URL na tej stronie:

http://localhost:51419/Home/About

Potem zmienił adres URL do tego:

http://localhost:51419/(A(a))/Home/About

a strona działa? Patrząc na wartości trasy, kontroler = Strona główna, Działanie = Informacje. Zignorowano pierwszą część?

A jeśli spojrzeć na wszystkie linki w źródle:

<link href="/(A(a))/Content/Site.css" rel="stylesheet" type="text/css" /> 
<script src="/(A(a))/Scripts/jquery-1.5.1.min.js" type="text/javascript"></script> 
<script src="/(A(a))/Scripts/modernizr-1.7.min.js" type="text/javascript"></script> 

<li><a href="/(A(a))/">Home</a></li> 
<li><a href="/(A(a))/Home/About">About</a></li> 

Zobacz, jak to utrzymywał, że pierwszej części? To tak, jak silnik routingu myśli, że jest częścią domeny czy coś takiego?

Mam wrażenie, że to regex sprawa, bo jeśli zmienię adres URL:

http://localhost:51419/(a(a))/Home/About

(np zmienił wielkiej litery A na małe litery)

To 404 jest.

Czy ktoś może rzucić trochę światła na to? Czy to błąd, czy projekt?

Answer 1

Wygląda na to, że ma on związek z sesjami bez plików cookie w potoku ASP.NET. To pasków, które URL wzór wewnątrz CookielessHelper.cs (System.Web.Security) podczas przetwarzania żądania:

// This function is called for all requests -- it must be performant. 
    // In the common case (i.e. value not present in the URI, it must not 
    // look at the headers collection 
    internal void RemoveCookielessValuesFromPath() 
    { 
     // See if the path contains "/(XXXXX)/" 
     string path  = _Context.Request.ClientFilePath.VirtualPathString; 
     // Optimize for the common case where there is no cookie 
     if (path.IndexOf('(') == -1) { 
      return; 
     } 
     int  endPos = path.LastIndexOf(")/", StringComparison.Ordinal); 
     int  startPos = (endPos > 2 ? path.LastIndexOf("/(", endPos - 1, endPos, StringComparison.Ordinal) : -1); 

     if (startPos < 0) // pattern not found: common case, exit immediately 
      return; 

     if (_Headers == null) // Header should always be processed first 
      GetCookielessValuesFromHeader(); 

     // if the path contains a cookie, remove it 
     if (IsValidHeader(path, startPos + 2, endPos)) 
     { 
      // only set _Headers if not already set 
      if (_Headers == null) { 
       _Headers = path.Substring(startPos + 2, endPos - startPos - 2); 
      } 
      // Rewrite the path 
      path = path.Substring(0, startPos) + path.Substring(endPos+1); 

      // remove cookie from ClientFilePath 
      _Context.Request.ClientFilePath = VirtualPath.CreateAbsolute(path); 
      // get and append query string to path if it exists 
      string rawUrl = _Context.Request.RawUrl; 
      int qsIndex = rawUrl.IndexOf('?'); 
      if (qsIndex > -1) { 
       path = path + rawUrl.Substring(qsIndex); 
      } 
      // remove cookie from RawUrl 
      _Context.Request.RawUrl = path; 

      if (!String.IsNullOrEmpty(_Headers)) { 
       _Context.Request.ValidateCookielessHeaderIfRequiredByConfig(_Headers); // ensure that the path doesn't contain invalid chars 
       _Context.Response.SetAppPathModifier("(" + _Headers + ")"); 

       // For Cassini and scenarios where aspnet_filter.dll is not used, 
       // HttpRequest.FilePath also needs to have the cookie removed. 
       string filePath = _Context.Request.FilePath; 
       string newFilePath = _Context.Response.RemoveAppPathModifier(filePath); 
       if (!Object.ReferenceEquals(filePath, newFilePath)) { 
        _Context.RewritePath(VirtualPath.CreateAbsolute(newFilePath), 
             _Context.Request.PathInfoObject, 
             null /*newQueryString*/, 
             false /*setClientFilePath*/); 
       } 
      } 
     } 
    } 

Twój wzór pasuje to:

/////////////////////////////////////////////////////////////////////// 
    /////////////////////////////////////////////////////////////////////// 
    // Make sure sub-string if of the pattern: A(XXXX)N(XXXXX)P(XXXXX) and so on. 
    static private bool IsValidHeader(string path, int startPos, int endPos) 
    { 
     if (endPos - startPos < 3) // Minimum len is "X()" 
      return false; 

     while (startPos <= endPos - 3) { // Each iteration deals with one "A(XXXX)" pattern 

      if (path[startPos] < 'A' || path[startPos] > 'Z') // Make sure pattern starts with a capital letter 
       return false; 

      if (path[startPos + 1] != '(') // Make sure next char is '(' 
       return false; 

      startPos += 2; 
      bool found = false; 
      for (; startPos < endPos; startPos++) { // Find the ending ')' 

       if (path[startPos] == ')') { // found it! 
        startPos++; // Set position for the next pattern 
        found = true; 
        break; // Break out of this for-loop. 
       } 

       if (path[startPos] == '/') { // Can't contain path separaters 
        return false; 
       } 
      } 
      if (!found) { 
       return false; // Ending ')' not found! 
      } 
     } 

     if (startPos < endPos) // All chars consumed? 
      return false; 

     return true; 
    } 

Answer 2

zgadzam się z analizą @pjumble, ale nie do jego rozwiązanie.
Wyłącz uwierzytelnianie bez dostępu do pliku dla uwierzytelniania formularza lub anonimowego uwierzytelniania.

Uniemożliwi to użytkownikom wyłączanie plików cookie w celu uwierzytelnienia. Ale kogo to obchodzi, teraz wszyscy mają ciasteczka aktywowane, ponieważ żadna nowoczesna strona internetowa nie będzie działać.

Dodaj w pliku web.config:

<anonymousIdentification enabled="false" /> 
<authentication mode="None" /> 

lub

<anonymousIdentification enabled="true" cookieless="UseCookies" ... /> 
<authentication mode="Forms"> 
    <forms name="Auth" cookieless="UseCookies" ... /> 
</authentication> 

Answer 3

Można spróbować dodawania IgnoreRoute do wyznaczaniu trasy - ale muszę przyznać, że nie jestem pewien, jaki format, aby zapewnić aby dopasować wszystkie możliwe ścieżki do gotowania.