HTTP Error 401.3 – Unauthorized
You do not have permission to view this directory or page because of the access control list (ACL) configuration or encryption settings for this resource on the Web server.

it is most likely because of missing or wrong NTFS permissions. In detail, the identity that is used by the IIS web-server for “Anonymous Authentication” needs read permission on the web application’s physical folder. By default this identity is set to “IUSR“. To solve the HTTP Error 401.3 you could either

• Grant read permissions on the web application’s physical folder for the IUSR user or
• change the identity that is used for “Anonymous Authentication” to a user that has the required read permissions. In order to change the identity use the IIS Manager, select the website, select “Authentication” (in section IIS), right click on “Anonymous Authentication”, run edit action and define a “Specific user”.

Related posts:

1. Microsoft CRM 4.0: Fix “TrySetFocusOnSubject” error after installing Update Rollup 12
2. ASP.NET: Prevent IIS 7.5 from overriding custom error pages with IIS default error pages
3. XenServer 5.6 & Debian Lenny: Fix apt-get/aptitude GPG error

<%
Response.Cache.SetCacheability(HttpCacheability.NoCache);
Response.Cache.SetNoStore();
%>

To prevent caching, these lines of code change the header of the server’s HTTP response by setting the following values:

• Cache-Control: no-cache, no-store
• Expires: -1
• Pragma: no-cache

You can read more about other possible caching options that can be passed to SetCacheability() here.

Related posts:

1. jQuery: Disable (browser) cache for all AJAX requests
2. Microsoft IIS 7: Enable Client Side Browser Caching for static Content in Web.config
3. ASP.NET development: Features, tips & tricks you should know about

Even though my implementation basically worked, there were several limitations (listed at the end of the blog post) that hinders using this approach in a real world project. Thanks to Fabian Schmied and his blog post “re-mix: Encapsulate and share ASP.NET MVC controller actions” it turned out that I was not aware of all the cool re-mix features that could solve the problems.

In this blog post I will show how to use Fabian’s suggestions to improve my first implementation. Summarized, his suggestions lead to a very a smooth integration of the re-mix library into a ASP.NET MVC 3 web application that enables adding actions to controllers without complex inheritance structures.

To understand the steps described below in detail it could be reasonable to download the source code of my first implementation. At the end of this post you find the download link for the updated version that includes all improvements.

Use IntroducedMemberVisibility = MemberVisibility.Public

When adding the Uses attribute to the controllers one could set IntroducedMemberVisibility = MemberVisibility.Public to tell re-mix to implement interface members publicly. As a result there is no need for the custom ControllerActionInvoker; the default ASP.NET MVC 3 ControllerActionInvoker will now find the actions defined in the mixins as if there were defined directly in the controller (like “normal” actions).
Instead of setting the option every time the remix UsesAttribute is used to annotate a controller, one could (as Fabian suggested) define a custom ControllerUsesMixinAttribute that takes care of setting the option:

public class ControllerUsesMixinAttribute : UsesAttribute
{
  public ControllerUsesMixinAttribute(Type mixinType) : base(mixinType)
  {
    IntroducedMemberVisibility = MemberVisibility.Public;
  }
}

and use this attribute to annotate the controllers:

[ControllerUsesMixinAttribute(typeof(EchoControllerMixin))]
public class Controller1Controller : Controller
{
}

Defined a IMixedController interface

To access the protected method defined in the default ASP.NET MVC 3 ControllerBase class one could specify a custom interface IMixedController like

public interface IMixedController
{
  ContentResult Content(string content);
  ControllerContext ControllerContext { get; }
}

and use this interface as TTarget type when defining the mixin class:

public class EchoControllerMixin : Mixin<IMixedController>, IEchoControllerMixin
{
  public ActionResult Echo(string id)
  {
    var controllerName = Target.ControllerContext.RouteData.Values["controller"].ToString();
    return Target.Content(string.Format("re-mix added 'Echo' action to controller '{0}'<hr/>You said: {1}", controllerName, !string.IsNullOrEmpty(id) ? id : "<i>nothing</i>"));
  }
}

Of course there are many more methods and properties defined in the ControllerBase class that could be added to the IMixedController interface.

RemixControllerFactory: Subclass DefaultControllerFactory instead of implementing IControllerFactory

The custom controller factory RemixControllerFactory is responsible for creating the concrete controller instance (which might be a re-mix proxy object if the controller has any UsesAttributes). In my first implementation I used ASP.NET MVC DefaultControllerFactory to create the controller object (without the “intermixed” actions) to get the type of the controller that should be used. In a second step, this type was passed to re-mix’s ObjectFactory to create the “correct” controller (containing the “intermixed” actions). The drawback of this approach is that the controller object is created twice.

A much better way is to subclass DefaultControllerFactory and override GetControllerType():

public class RemixControllerFactory : DefaultControllerFactory
{
  protected override Type GetControllerType(RequestContext requestContext, string controllerName)
  {
    var baseControllerType = base.GetControllerType(requestContext, controllerName);
    return Remotion.Mixins.TypeFactory.GetConcreteType(baseControllerType);
  }
}

I updated the source code and the Visual Studio 2010 project, you can download the new version here.

Related posts:

1. ASP.NET MVC 3: Use re-mix library to add controller actions with mixins
2. ASP.NET MVC3: Controller extension methods to render a partial view to string
3. ASP.NET MVC 3: How to get the current controller and action in a Razor view

One scenario where more than one submit button is useful is for example a form that enables the user to update a dataset or to save the data as a new dataset. On the server side, one would implement two actions (like Update() and AddNew()) and requires a logic that decides which actions should be executed depending on which button was clicked.

There are approaches that solve this problem by decorate the actions with additional attributes:

• http://blog.maartenballiauw.be/post/2009/11/26/Supporting-multiple-submit-buttons-on-an-ASPNET-MVC-view.aspx
• http://blog.ashmind.com/2010/03/15/multiple-submit-buttons-with-asp-net-mvc-final-solution

The basic idea of these approaches is to set the name attribute of the submit button’s <input> tag and implement a custom ActionNameSelectorAttribute that tests the submitted data of the HTTP request against this value to decide whether the action should be executed or not.

In this blog post I will show how to implement a custom HTML Helper that supports creating forms with multiple submit buttons. The benefit of this approach is that no changes on the server side (like additional attributes) are required. The drawback of this solution is that it depends on JavaScript (jQuery), i.e. it only works in browsers with JavaScript support enabled.

The HTML Helper MultiSubmitButton shown below depends on the SubmitButton() HTML Helper of the ASP.NET MVC 3 Futures library. One could use the NuGet package manager to install MVC 3 Futures

PM> Install-Package Mvc3Futures

or download the files here.

The MultiSubmitButton HTML Helper works like the MVC 3 Futures’ SubmitButton HTML Helper but has an additional (string) parameter url which defines the URL of the action that should be called when the button was clicked. The implementation looks as follows:

public static class MultiSubmitButtonExtension
{
  public static MvcHtmlString MultiSubmitButton(this HtmlHelper helper, string url, string name)
  {
    return MultiSubmitButton(helper, url, name, null, (IDictionary<string, object>)null);
  }
  public static MvcHtmlString MultiSubmitButton(this HtmlHelper helper, string url, string name, string buttonText)
  {
    return MultiSubmitButton(helper, url, name, buttonText, null);
  }
  public static MvcHtmlString MultiSubmitButton(this HtmlHelper helper, string url)
  {
    return MultiSubmitButton(helper, url, null, null, (IDictionary<string, object>)null);
  }
  public static MvcHtmlString MultiSubmitButton(this HtmlHelper helper, string url, string name, string buttonText, object htmlAttributes)
  {
    return helper.MultiSubmitButton(url, name, buttonText, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
  }
  public static MvcHtmlString MultiSubmitButton(this HtmlHelper helper, string url, string name, string buttonText, IDictionary<string, object> htmlAttributes)
  {
    htmlAttributes = htmlAttributes ?? new Dictionary<string, object>();
 
    // Add onClick handler
    string onClick = "$(this).parents('form').attr('action', '" + url + "');";
    if (htmlAttributes.ContainsKey("onClick")) {
      htmlAttributes["onClick"] = htmlAttributes["onClick"] + ";" + onClick;
    } else {
      htmlAttributes.Add("onClick", onClick);
   }
    return helper.SubmitButton(name, buttonText, htmlAttributes);
  }
}

You can combine the MultiSubmitButton HTML Helper with ordinary submit buttons: The multi submit buttons will call the action that is defined with its url parameter and the ordinary submit buttons will call the form’s default action (defined in the form’s action attribute).

Here is an example how to use the MultiSubmitButton HTML Helper:

@using (Html.BeginForm("DefaultAction", "Controller"))
{
 
  // Add input fields here ...
 
  @Html.SubmitButton("button1", "Default Action");
  @Html.MultiSubmitButton(Url.Action("FormAction1"), "button2", "Action 1");
  @Html.MultiSubmitButton(Url.Action("FormAction2"), "button3", "Action 2");
 
}

As you can see in the example above one could use the Url.Action() method to easily generate the URL that is passed to the MultiSubmitButton helper.

A running Visual Studio 2010 project containing all the source code could be downloaded here.

Related posts:

1. ASP.NET MVC 3: Using jQuery .ajax() function to submit Ajax Form supporting (unobtrusive) Client Side Validation and Server Side Validation
2. ASP.NET MVC 3: Strongly typed Authorize Attribute with multiple users and roles
3. ASP.NET MVC 3: Ajax Form with jQuery validate supporting (unobtrusive) Client Side Validation and Server Side Validation

The basic idea is as follows: Two actions exists on the server side; one action starts the (long running) task in a new thread and returns a unique identifier (GUID in this example) to the client and the second action returns the current (percentaged) status for a specific task.

For simplicity, in this example all (server side) functionality is implemented in the HomeController:

public class HomeController : Controller
{
  private static IDictionary<Guid, int> tasks = new Dictionary<Guid, int>();
 
  public ActionResult Index()
  {
    return View();
  }
 
  public ActionResult Start()
  {
    var taskId = Guid.NewGuid();
    tasks.Add(taskId, 0);
 
    Task.Factory.StartNew(() =>
    {
      for (var i = 0; i <= 100; i++)
      {
        tasks[taskId] = i; // update task progress
        Thread.Sleep(50); // simulate long running operation
      }
      tasks.Remove(taskId);
    });
 
    return Json(taskId);
  }
 
  public ActionResult Progress(Guid id)
  {
    return Json(tasks.Keys.Contains(id) ? tasks[id] : 100);
  }
}

The HomeController uses a Dictionary to save the progresses of all tasks. The Start action adds a new entry to this dictionary (with progress 0) and starts a new Task that simulates the long running operation. It is important to understand that this (time-consuming) operation is running in a separate thread and server immediately returns a result to the client (the unique identifier of the task), i.e. there is no HTTP request that is open as long as the task runs. The Progress action just returns the progress for a given GUID that uniquely identifies a task. Both actions return a JSON-result to enable easily processing of the data on the client side.

The client side functionality is implemented in the Index.cshtml view:

<script type="text/javascript">
 
function updateMonitor(taskId, status) {
  $("#" + taskId).html("Task [" + taskId + "]: " + status);
}
 
$(function () {
  $("#start").click(function (e) {
    e.preventDefault();
    $.post("Home/Start", {}, function (taskId) {
 
      // Init monitors
      $("#monitors").append($("<p id='" + taskId + "'/>"));
      updateMonitor(taskId, "Started");
 
      // Periodically update monitors
      var intervalId = setInterval(function () {
        $.post("Home/Progress", { id: taskId }, function (progress) {
          if (progress >= 100) {
            updateMonitor(taskId, "Completed");
          clearInterval(intervalId);
          } else {
            updateMonitor(taskId, progress + "%");
          }
        });
      }, 100);
    });
  });
});
</script>
 
<div id="monitors"></div>

On the client side the jQuery function $.post() is used to

• first “call” the URL Home/Start to start a new task
• and then periodically pass the returned GUID to the URL Home/Progress to get the current progress.

To show some feedback to the user a <p> tag is created for each started task and periodically updated with the current progress.

Note: The approach shown above supports multiple parallel running tasks. You can click the “start” link while other task(s) are still running.

The code shown above is only exemplary. In a real-world project one should implement a robust error handling to support for example situations where the tasks are interrupted. Furthermore it could be reasonable to limit the number of parallel tasks one user could start, since long running tasks are often need much resources.

You can download the Visual Studio 2010 project containing all the source code here.

Related posts:

1. ASP.NET MVC 3: Using jQuery .ajax() function to submit Ajax Form supporting (unobtrusive) Client Side Validation and Server Side Validation
2. ASP.NET MVC 3: Using JSON result for jQuery Ajax Forms validation
3. ASP.NET MVC 3: Ajax Form with jQuery validate supporting (unobtrusive) Client Side Validation and Server Side Validation

Tip 1: SMTP setting deliveryMethod “SpecifiedPickupDirectory”

While developing an ASP.NET web application one could use the SMTP settings deliveryMethod=”SpecifiedPickupDirectory” to save all e-mails to a local directory (as .eml files) instead of sending them to a SMTP server.

<configuration>
  [...]
  <system.net>
    <mailSettings>
      <smtp deliveryMethod="SpecifiedPickupDirectory">
        <specifiedPickupDirectory pickupDirectoryLocation="c:\temp\"/>
      </smtp>
    </mailSettings>
  </system.net>
  [...]
</configuration>

Using this configuration in the development environment one neither need a running SMTP server nor one need to worry about sending any e-mail to (other) recipients. It could be reasonable to put the configuration in the machine.config file on the development machine to configure all applications to save the e-mails as files.

Tip 2: Compilation setting “optimizeCompilations”

To speed up the development process one could set the optimizeCompilations compilation setting to true. When setting this value to true only the affected files are recompiled when a change to a top-level file (for example a changed file in the bin folder) is detected. Especially when developing large web applications this could save much time because it significantly decreases the application’s start-up time.

<configuration>
  [...]
  <system.web>
    <compilation optimizeCompilations="true">
      [...]
    </compilation>
  </system.web>
  [...]
</configuration>

Depending on the type of changes one made to a top-level file, using this optimization could result in run-time errors (see http://msdn.microsoft.com/en-us/library/ms366723.aspx for detailed information). To force a complete recompilation of the application just set the optimizeCompilations flag temporarily back to false.

Tip 3: IIS: app_offline.htm offline page

An easy way to (temporarily) put an ASP.NET web application offline is to create a file named app_offline.htm in the root directory of the application. The IIS web-server automatically shuts down the ASP.NET application and returns the content of the app_offline.htm (and a HTTP status code 503 “Service Unavailable”) to all new incoming requests. To support Internet Explorer 6, the app_offline.htm file needs at least 512 bytes of content (one can increase the file size for example by adding some html comments).

To start the ASP.NET application again just remove or rename the app_offline.htm file.

Note: Before .NET 4 the web-server returns a status code 404 (“Page not Found”) instead of 503 (“Service Unavailable”) when serving the app_offline.htm which could cause the web page from being removed from search engine indexes (see here). Therefore, when using an older version of the .NET framework it is recommendable to add a custom aspx page that is used as “offline page” and adding the following lines of code to set the correct HTTP status code:

Response.Status = "503 Service Unavailable";
Response.StatusCode = 503;

Tip 4: Get Page instance from HttpContext object

Use the following code snippet to get the Page instance from the (current) HttpContext object:

Page page = HttpContext.Current.Handler as Page;
if (page != null)
{
  // Do something with the Page instance
}
else
{
  // No Page instance available 
}

Tip 5: HttpContext.Items as request-level cache

An easy way to cache arbitrary data in the scope of the current HTTP context is to use the HttpContext.Items dictionary:

HttpContext.Current.Items["MyKey"] = myObject;

A use case is shown in my blog post “ASP.NET MVC 3: How to use the Unit of Work pattern with Unity 2.0″ when implementing the HttpContextLifetimeManager.

Related posts:

1. Android development: Restart application programmatically
2. ASP.NET MVC: How to add ELMAH (Error Logging Modules and Handlers for ASP.NET)
3. ASP.NET MVC 3: How to use the Unit of Work pattern with Unity 2.0

In this showcase we will implement custom error pages to handle the HTTP error codes 404 (“Not Found”) and 500 (“Internal server error”) which I think are the most common errors that could occur in web applications. In a first step we will set up the custom error pages to handle errors occurring in “normal” non-AJAX requests and in a second step we add a little JavaScript jQuery code that handles jQuery AJAX errors.

We start with a new (empty) ASP.NET MVC 3 project and activate custom errors in the Web.config by adding the following lines under <system.web>:

<customErrors mode="On" defaultRedirect="/Error">
  <error redirect="/Error/NotFound" statusCode="404"/>
  <error redirect="/Error/InternalServerError" statusCode="500"/>
</customErrors>

Note: You can set mode=”Off” to disable custom errors which could be helpful while developing or debugging. Setting mode=”RemoteOnly” activates custom errors only for remote clients, i.e. disables custom errors when accessing via http://localhost/[...]. In this example setting mode=”On” is fine since we want to test our custom errors. You can find more information about the <customErrors> element here.

In a next step we remove the following line in Global.asax.cs file:

filters.Add(new HandleErrorAttribute());

and add a new ErrorController (Controllers/ErrorController.cs):

public class ErrorController : Controller
{
  public ActionResult Index()
  {
    return InternalServerError();
  }
 
  public ActionResult NotFound()
  {
    Response.TrySkipIisCustomErrors = true;
    Response.StatusCode = (int)HttpStatusCode.NotFound;
    return View("NotFound");
  }
 
  public ActionResult InternalServerError()
  {
    Response.TrySkipIisCustomErrors = true;
    Response.StatusCode = (int)HttpStatusCode.InternalServerError;
    return View("InternalServerError");
  }
}

In a last step we add the ErrorController‘s views (Views/Error/NotFound.cshtml and Views/Error/InternalServerError.cshtml) that defines the (error) pages the end user will see in case of an error. The views include a partial view defined in Views/Shared/Error/NotFoundInfo.cshtml respectively Views/Shared/Error/InternalServerErrorInfo.cshtml that contains the concrete error messages. As we will see below using these partial views enables us to reuse the same error messages to handle AJAX errors.

Views/Error/NotFound.cshtml:

@{
  ViewBag.Title = "Not found";
}
@{
  Html.RenderPartial("Error/NotFoundInfo");
}

Views/Shared/Error/NotFoundInfo.cshtml:

The URL you have requested was not found.

Views/Error/InternalServerError.cshtml:

@{
  ViewBag.Title = "Internal server error";
}
@{
  Html.RenderPartial("Error/InternalServerErrorInfo");
}

Views/Shared/Error/InternalServerErrorInfo.cshtml:

An internal Server error occured.

To handle errors occurring in (jQuery) AJAX calls we will use jQuery UI to show a dialog containing the error messages. In order to include jQuery UI we need to add two lines to Views/Shared/_Layout.cshtml:

<link href="@Url.Content("~/Content/themes/base/jquery.ui.all.css")" rel="stylesheet" type="text/css" />
<script src="@Url.Content("~/Scripts/jquery-ui-1.8.11.min.js")" type="text/javascript"></script>

Moreover we add the following jQuery JavaScript code (defining the global AJAX error handling) and the Razor snippet (defining the dialog containers) to Views/Shared/_Layout.cshtml:

<script type="text/javascript">
  $(function () {
    // Initialize dialogs ...
    var dialogOptions = {
      autoOpen: false,
      draggable: false,
      modal: true,
      resizable: false,
      title: "Error",
      closeOnEscape: false,
      open: function () { $(".ui-dialog-titlebar-close").hide(); }, // Hide close button
      buttons: [{
        text: "Close",
        click: function () { $(this).dialog("close"); }
      }]
    };
    $("#InternalServerErrorDialog").dialog(dialogOptions);
    $("#NotFoundInfoDialog").dialog(dialogOptions);
 
    // Set up AJAX error handling ...
    $(document).ajaxError(function (event, jqXHR, ajaxSettings, thrownError) {
      if (jqXHR.status == 404) {
        $("#NotFoundInfoDialog").dialog("open");
      } else if (jqXHR.status == 500) {
        $("#InternalServerErrorDialog").dialog("open");
      } else {
        alert("Something unexpected happend :( ...");
      }
    });
  });
</script>

<div id="NotFoundInfoDialog">
  @{ Html.RenderPartial("Error/NotFoundInfo"); }
</div>
<div id="InternalServerErrorDialog">
  @{ Html.RenderPartial("Error/InternalServerErrorInfo"); }
</div>

As you can see in the Razor snippet above we reuse the error texts defined in the partial views saved in Views/Shared/Error/.

To test our custom errors we define the HomeController (Controllers/HomeController.cs) as follows:

  public class HomeController : Controller
  {
  public ActionResult Index()
  {
    return View();
  }
  public ActionResult Error500()
  {
    throw new Exception();
  }
}

and the corresponding view Views/Home/Index.cshtml:

@{
  ViewBag.Title = "ViewPage1";
}
 
<script type="text/javascript">
  $function () {
    $("a.ajax").click(function (event) {
      event.preventDefault();
      $.ajax({
      url: $(this).attr('href'),
    });
  });
});
</script>
 
<ul>
  <li>@Html.ActionLink("Error 404 (Not Found)", "Error404")</li>
  <li>@Html.ActionLink("Error 404 (Not Found) [AJAX]", "Error404", new { }, new { Class = "ajax" })</li>
  <li>@Html.ActionLink("Error 500 (Internal Server Error)", "Error500")</li>
  <li>@Html.ActionLink("Error 500 (Internal Server Error) [AJAX]", "Error500", new { }, new { Class = "ajax" })</li>
</ul>

To test the custom errors you can launch the project and click one of the four links defined in the view above. The “AJAX links” should open a dialog containing the error message and the “non-AJAX” links should redirect to a new page showing the same error message.

You can download the Visual Studio 2010 project containing all the source code here.

Summarized this blog post shows how to set up custom errors that handle errors occurring in both AJAX requests and “non-AJAX” requests. Depending on the project, one could customize the example code shown above to handle other HTTP errors as well or to show more customized error messages or dialogs.

When thinking about error handling in ASP.NET MVC 3 applications you should take a look at ELMAH (Error Logging Modules and Handlers for ASP.NET), a tool that logs/handles errors on server side and which works perfectly in combination with the approach shown above. I wrote a blog post about how to set up and configure ELMAH in a ASP.NET MVC application.

Related posts:

1. ASP.NET: Prevent IIS 7.5 from overriding custom error pages with IIS default error pages
2. ASP.NET MVC 3: Using jQuery .ajax() function to submit Ajax Form supporting (unobtrusive) Client Side Validation and Server Side Validation
3. ASP.NET MVC 3: Using JSON result for jQuery Ajax Forms validation

Update 2012-01-10 Fabian Schmied (re-mix developer) published a blog post “re-mix: Encapsulate and share ASP.NET MVC controller actions” which shows possible solutions to the problems I’ve listed in this post.

When developing ASP.NET MVC3 application one often needs to add similar actions to different controllers; for example controllers that enable the user to perform the basic CRUD (create, read, update, delete) operations typically contain action methods like Create(), Update() or Delete(). To avoid duplicate code a simple solution could be a common base controller. In complex applications this approach could have some limitations, since .NET does not support multi inheritance, e.g. each controller could have only one base controller.

This blog post shows a prototypically approach how to implement action methods that can be used in more than one controller with the help of the re-mix library which adds mixins support to .NET. Since the approach shown below is only a proof of concept, it has some limitations that are listed at the end of the post.

After downloading re-mix and adding references to the dll files contained in the folder net-3.5\bin\release one need a custom controller factory that uses remix’s ObjectFactory to create the controller objects:

public class RemixControllerFactory : IControllerFactory
{
  private IControllerFactory _defaultControllerFactory;
 
  public RemixControllerFactory()
  {
    _defaultControllerFactory = new DefaultControllerFactory();
  }
 
  public IController CreateController(RequestContext requestContext, string controllerName)
  {
    // Use the default ControllerFactory to get the type of the controller
    var controllerType = _defaultControllerFactory.CreateController(requestContext, controllerName).GetType();
 
    // Use remix's ObjectFactory to instantiate the (mixed) controller
    return (IController)ObjectFactory.Create(controllerType);
  }
 
  public SessionStateBehavior GetControllerSessionBehavior(RequestContext requestContext, string controllerName)
  {
    return SessionStateBehavior.Default;
  }
 
  public void ReleaseController(IController controller)
  {
  }
}

The custom RemixControllerFactory is set as the default controller factory in the Global.asax.as file:

protected void Application_Start()
{
  [...]
  ControllerBuilder.Current.SetControllerFactory(new RemixControllerFactory());
  [...]
}

In a next step we implement the interface that defines the action methods (Echo in this example) that will be used to extend the controllers:

public class IEchoControllerMixin
{
  ActionResult Echo(string id);
}

In a last step we implement the IEchoControllerMixin:

public class EchoControllerMixin : Mixin<ControllerBase>, IEchoControllerMixin
{
  public ActionResult Echo(string id)
  {
    var result = new ContentResult();
    var controllerName = Target.ControllerContext.RouteData.Values["controller"].ToString();
    result.Content = string.Format("re-mix added Echo action to controller '{0}'<hr/>You said: {1}", controllerName, !string.IsNullOrEmpty(id) ? id : "<i>nothing</i>");
    return result;
  }
 
  [OverrideTarget]
  protected IActionInvoker CreateActionInvoker()
  {
    return new RemixControllerActionInvoker(typeof(IEchoControllerMixin));
  }
}

Due to security reasons ASP.NET MVC only allows to call action methods that are defined in a class that inherits System.Web.Mvc.ControllerBase. Since re-mix creates (automatically generated) proxy objects with their own inheritance structures, ASP.NET MVC does not find the Echo action by default. To bypass this limitation we implement a custom RemixControllerActionInvoker that allows calling actions that are defined in implementations of the IEchoControllerMixin interface. To do this we use reflection to call a non-public ASP.NET MVC functionality that creates an ActionDescriptor that skip the security check:

public class RemixControllerActionInvoker : ControllerActionInvoker
{
  private Type _remixType;
 
  public RemixControllerActionInvoker(Type remixType)
  {
    _remixType = remixType;
  }
 
  protected override ActionDescriptor FindAction(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName)
  {
    // Use default action descriptor
    ActionDescriptor actionDescriptor = controllerDescriptor.FindAction(controllerContext, actionName);
    if (actionDescriptor != null) return actionDescriptor;
 
    // Create action descriptor that accepts actions that are defined in the remix type
    var internalConstructor = typeof(ReflectedActionDescriptor).GetConstructor(
      BindingFlags.NonPublic | BindingFlags.Instance, null, new [] { typeof(MethodInfo), typeof(string), typeof(ControllerDescriptor), typeof(bool) }, null
    );
    return (ActionDescriptor)internalConstructor.Invoke(new object[] { _remixType.GetMethod(actionName), actionName, controllerDescriptor, false });
  }
}

After all the preparations we are finally able to “intermix” the Echo action to any controller:

[Uses(typeof(EchoControllerMixin))]
public class Controller1Controller : Controller
{
}
[Uses(typeof(EchoControllerMixin))]
public class Controller2Controller : Controller
{
}

To test the Echo action in both controllers, just open http://localhost:[...]/Controller1/Echo/Hello or http://localhost:[...]/Controller2/Echo/Hello.

Summarized mixins enable adding actions to controllers without the need of a common base controller; actions defined in mixins are completely decoupled from any inheritance structure and can be added to any controller.

As written in introduction, the approach shown above is only prototypical and has some limitations (which should be resolvable with some additional logic/code):

1. Since the mixin overrides the CreateActionInvoker() of the controller that is “intermixed”, one could neither use more than one mixin in one controller nor use a custom CreateActionInvoker() method.
2. In actions defined in mixins one does not have access to the protected ASP.NET MVC controller methods that create ActionResult objects like View(), PartialView(), Json(), Content(), …
3. One needs to use reflection to call a protected ReflectedActionDescriptor constructor.
4. The RemixControllerActionInvoker implementation does not consider the action parameter when creating the action descriptor. In result the action names defined in the mixins needs to be unique.

You can download the Visual Studio 2010 project containing all the source code here.

Related posts:

1. ASP.NET MVC 3: Use re-mix library to add controller actions with mixins – Part 2
2. ASP.NET MVC3: Controller extension methods to render a partial view to string
3. ASP.NET MVC 3: How to get the current controller and action in a Razor view

Could not establish trust relationship for the SSL/TLS secure channel with authority [...].

To instruct WCF to accept all certificates use the following code before consuming any services:

ServicePointManager.ServerCertificateValidationCallback += (sender, cert, chain, errors) => true;

Self-signed certificates are often used in development environments. Due to security reasons, in a production environment you should never use the code above; instead you should always use valid certificates and prohibit any communication in case of certificate problems!

Related posts:

1. CACert.org & Apache2: Create and use free public key certificates
2. ASP.NET: Programmatically adding <script> tags to include JavaScript files in the master page’s <head> tag
3. Android development: Restart application programmatically

public class ExampleController : Controller
{
  [Authorize(Users="User1,User2", Roles="Role1,Role2")]
  public ActionResult ExampleAction()
  {
    [...]
  }
}

As you can see in the above example the users and roles are defined using a comma separated string. In complex applications it is often preferable to use a strongly typed approach instead of comma separated strings, which make renaming of roles error-prone and cumbersome. For example, the roles could be defined as constants in a utility class:

public class Roles
{
  public const string Role1 = "Role1";
  public const string Role2 = "Role2";
  public const string Role3 = "Role3";
}

Since one has to use a constant expression when defining attributes one cannot define the Authorize attribute as follows:

[Authorize(Roles = String.Join(",", new[] { Role1, Role2 })))]

To overcome this limitation, I created a custom MultiAuthorize attribute that subclasses the default Authorize attribute and uses arrays to define the Roles and Users properties:

public class MultiAuthorizeAttribute : AuthorizeAttribute
{
  public new string[] Roles
  {
    get { return base.Roles.Split(','); }
    set { base.Roles = string.Join(",", value); }
  }
  public new string[] Users
  {
    get { return base.Users.Split(','); }
    set { base.Users = string.Join(",", value); }
  }
}

Using this custom attribute, one can use arrays containing the strongly-typed roles:

[MultiAuthorize(Roles = new[] { Role1, Role2 })]

Related posts:

1. ASP.NET MVC 3: Support multiple submit buttons in one form with HTML Helper MultiSubmitButton
2. ASP.NET MVC 3: Use re-mix library to add controller actions with mixins – Part 2
3. ASP.NET MVC3: Controller extension methods to render a partial view to string