Nel mio viaggio da MonoRail ad ASP.NET MVC 2.0 mi è capitato di dover gestire una serie di link esterni che richiamavano pagine del sito sui quali non avevo controllo e che ovviamente utilizzavano l'estensione ".rails" tipica di MonoRail. Visto che i nomi di controller ed action erano rimasti comunque invariati ho pensato di utilizzare il sistema di routing di ASP.NET.

Una delle caratteristiche più interessanti del routing di ASP.NET è la possibilità di specificare dei constraint nella registrazione di una route attraverso implementazione di IRouteConstraint. Il ruolo del constraint è quello di definire la validità della regola per la richiesta corrente. Il primo passo da compiere sarà quindi quello di definire un constraint che ci permetta di escludere dai nostri routing le richieste con estensione ".rails". Qui sotto possiamo vedere nel dettaglio il codice:

public class NotContainsRouteConstraint : IRouteConstraint
{
  private string _value;
 
  public NotContainsRouteConstraint(string value)
  {
    _value = value;
  }
 
  public bool Match(HttpContextBase httpContext, 
                    Route route, 
                    string parameterName, 
                    RouteValueDictionary values, 
                    RouteDirection routeDirection)
  {
    var paramValue = values[parameterName].ToString();
    return !paramValue.Contains(_value);
  }
}

Nel metodo di registrazione delle regole di routing nel Global.asax aggiungiamo alle regola già configurate la constraint per le action che contengono la stringa ".rails" e definiamo una nuova regola che invece le consideri. Qui sotto possiamo vedere un esempio di configurazione, attenzione però che se abbiamo ulteriori regole dobbiamo valutare di volta in volta se aggiungere il constraint in base al fatto che queste regole eseguano il match con le chiamate alle pagine di MonoRail.

public static void RegisterRoutes(RouteCollection routes)
{
  routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
  routes.IgnoreRoute("favicon.ico");
 
  routes.MapRoute(
   "Default",
   "{controller}/{action}/{id}",
   new {controller="Home", action="Index", id=UrlParameter.Optional},
   new {action = new NotContainsRouteConstraint(".rails")}
  );
  routes.MapRoute(
   ".rails",
   "{controller}/{action}.rails",
   new {controller="Home", action="Index", id=UrlParameter.Optional}
  );
  routes.MapRoute(
   "Root",
   "",
   new {controller="Home", action="Index", id=UrlParameter.Optional}
  );
}

Immaginiamo di voler chiamare una action di un controller ASP.NET MVC passando una serie di parametri. Normalmente attraverso la chiamata a RedirectToAction utilizziamo un anonymous type, ma la precondizione è di conoscere il nome dei parametri da passare.
Nel caso in oggetto però noi non conosciamo a priori il nome dei parametri, come possiamo fare? In questa circostanza possiamo utilizzare la proprietà RouteData della classe Controller e precisamente la sua proprietà Values, un dizionario che contiene tutti i valori della richiesta:

//parameters è la collezione che contiene i parametri da passare
foreach(var key in parameters.AllKeys)
{
   RouteData.Values.Add(key, parameters[key]);
}
return RedirectToAction("[action]", "[controller]", 
                        RouteData.Values);

Per chi fosse interessato sono disponibili per il download le slide e la demo dell'evento di giovedì scorso organizzato da 1nn0va sul Model View Controller. Nella demo i progetti di esempio con il confronto tra WebForms, ASP.NET MVC e MonoRail.

Per scaricare i file cliccare sui link qui sotto:

• Slide Model View Controller 
• Applicazioni di esempio

Nei Dynamic Data quando abbiamo una relazione uno a molti possiamo utilizzare l'attributo DisplayColumn per determinare quale tra le proprietà della classe sulla parte uno della relazione viene utilizzata nel testo del link.

[MetadataType(typeof(CustomerMetadata))]
[DisplayColumn("CompanyName", "CompanyName", false)]
public partial class Customer
{
   ...
}

Analizzando nel dettaglio il controllo ForeignKey.ascx che visualizza il campo chiave esterna notiamo che il testo del link viene popolato utilizzando il metodo GetDisplayString della classe MetaTable. Utilizzando Reflector vediamo come si comporta questo metodo:

public string GetDisplayString(object row)
{
  if (row != null)
  {
    row = this.PreprocessRowObject(row);
    if (this.HasToStringOverride)
    {
      return row.ToString();
    }
    object propertyValue = 
      DataBinder.GetPropertyValue(row, this.DisplayColumn.Name);
    if (propertyValue != null)
    {
      return propertyValue.ToString();
    }
  }
  return string.Empty;
}

Dall'analisi del codice notiamo come l'attributo DisplayColumn non abbia effetto se abbiamo eseguito l'override del metodo ToString() nella classe della chiave esterna.

In questo modo se nella classe Customer dell'esempio andiamo ad eseguire l'override del metodo ToString() nel seguente modo...

public override string ToString()
{
  return String.Format("{0} - ({1})", this.CompanyName, this.Country);
} 

... l'effetto che otteniamo è il seguente:

Ovviamente possiamo ovviare a questo comportamento modificando opportunamente il controllo ForeignKey affinché utilizzi direttamente l'attributo DisplayColumn.