How do I return a generic response and response code from all the features of a .NET MVC application?

The switch statement in your ValidateResetHash answer is smelly code. This tells me that you can use the subclassable enum . The subclassed enumeration will map action response codes or types to return views using models. Here is a compiled example of how to use it.

First, I used some fillable classes to get a compilation example:

public class GenericActionModel
{
    private bool v1;
    private string v2;
    private string v3;
    private string v4;
    private bool v5;

    protected GenericActionModel() {}
    public GenericActionModel(bool v1, string v2, string v3, string v4, bool v5)
    {
        this.v1 = v1;
        this.v2 = v2;
        this.v3 = v3;
        this.v4 = v4;
        this.v5 = v5;
    }
}

public class ActionResult
{
    private GenericActionModel responseModel;
    private string v;

    public ActionResult(string v, GenericActionModel responseModel)
    {
        this.v = v;
        this.responseModel = responseModel;
    }
}

public class PasswordChangeModel : GenericActionModel
{
    public object PasswordResetHash
    {
        get;
        set;
    }
}

public interface IUserManager
{
    Response IsValidPasswordResetHash(string passwordResetHash);
}

      

        
        
        
      

    

Here are some framework classes (I'm using the base StringEnum class from the AtomicStack project for the base ResponseEnum class):

public abstract class Response
{
    public abstract string name { get; }
}

public class Response<TResponse> : Response where TResponse : Response<TResponse>
{
    private static string _name = typeof(TResponse).Name;
    public override string name => _name;
}

// Base ResponseEnum class to be used by more specific enum sets
public abstract class ResponseEnum<TResponseEnum> : StringEnum<TResponseEnum>
    where TResponseEnum : ResponseEnum<TResponseEnum>
{
    protected ResponseEnum(string responseName) : base(responseName) {}
    public abstract ActionResult GenerateView(Response response);
}

      

        
        
        
      

    

Here are some sample responses:

public class HashValidated : Response<HashValidated>
{
    public string passwordResetHash;
}
public class InvalidHash : Response<InvalidHash> {}
public class PasswordResetHashExpired : Response<PasswordResetHashExpired> {}
public class Unexpected : Response<Unexpected> {}

      

        
        
        
      

    

An example of a subclassed enumeration displaying the sample responses would look something like this:

public abstract class ValidateHashResponses : ResponseEnum<ValidateHashResponses>
{

    public static readonly ValidateHashResponses HashOk                     = HashValidatedResponse.instance;
    public static readonly ValidateHashResponses InvalidHash                = InvalidHashResponse.instance;
    public static readonly ValidateHashResponses PasswordResetHashExpired   = PasswordResetHashExpiredResponse.instance;
    public static readonly ValidateHashResponses Default                    = DefaultResponse.instance;

    private ValidateHashResponses(string responseName) : base(responseName) {}

    protected abstract class ValidateHashResponse<TValidateHashResponse, TResponse> : ValidateHashResponses
        where TValidateHashResponse : ValidateHashResponse<TValidateHashResponse, TResponse>, new()
        where TResponse : Response<TResponse>
    {
        public static TValidateHashResponse instance = new TValidateHashResponse();
        private static string name = Response<TResponse>.Name;
        protected ValidateHashResponse() : base(name) {}
    }

    protected class HashValidatedResponse : ValidateHashResponse<HashValidatedResponse, HashValidated>
    {
        public override ActionResult GenerateView(Response response)
        {
            PasswordChangeModel model = new PasswordChangeModel();
            model.PasswordResetHash = ((HashValidated) response).passwordResetHash;
            return new ActionResult("~/Areas/Public/Views/ResetPassword/PasswordChangeForm.cshtml", model);
        }
    }

    protected class InvalidHashResponse : ValidateHashResponse<InvalidHashResponse, InvalidHash>
    {
        public override ActionResult GenerateView(Response response)
        {
            GenericActionModel responseModel = new GenericActionModel(true, "/Login", "Login", "You have submitted an invalid password reset link.", false);
            return new ActionResult("~/Views/Shared/GenericAction.cshtml", responseModel);
        }
    }

    protected class PasswordResetHashExpiredResponse : ValidateHashResponse<PasswordResetHashExpiredResponse, PasswordResetHashExpired>
    {
        public override ActionResult GenerateView(Response response)
        {
            GenericActionModel responseModel = new GenericActionModel(true, "/ResetPassword", "Reset Password", "You have submitted an expired password reset link. You must reset your password again to change it.", false);
            return new ActionResult("~/Views/Shared/GenericAction.cshtml", responseModel);
        }
    }

    protected class DefaultResponse : ValidateHashResponses
    {
        public static DefaultResponse instance = new DefaultResponse();
        private DefaultResponse() : base("Default") {}
        public override ActionResult GenerateView(Response response)
        {
            GenericActionModel responseModel = new GenericActionModel(true, "/", "Home", "An unknown error has occured. The system administrator has been notified. Error code:" + response.name, false);
            return new ActionResult("~/Views/Shared/GenericAction.cshtml", responseModel);
        }
    }

}

      

        
        
        
      

    

SampleController implementation:

public class SampleController
{
    private IUserManager _userManager;
    public ActionResult ValidateResetHash(string passwordResetHash)
    {
        Response    result      = this._userManager.IsValidPasswordResetHash(passwordResetHash);
        var         resultType  = ValidateHashResponses.TrySelect(result.name,ValidateHashResponses.Default);
        return resultType.GenerateView(result);
    }

}

      

        
        
        
      

    

Modify the code above to suit your situation.

If you want to allow others to extend the ValidateHashResponses enumeration, you can make the constructor protected instead of private. They can then extend ValidateHashResponses and add their own additional enumeration values.

The point of using a subclassed enumeration, it is to use the TrySelect method, which allows responses to a specific enumeration value. Then we call the GenerateView method on the enum value to create the view.

Another advantage of enumeration is that if you need to make other decisions based on the enum value, you simply add another abstract method to the enum, and all value definitions will be forced to implement a new abstract method, unlike traditional enum / switch. where new enum values ​​are not required to add cases, and where one might forget to revise all switch statements that used enumeration.

DISCLAIMER : I am the author of the AtomicStack project. Feel free to use the enum subclass class code from the project if you think it will suit your needs.

UPDATE

If you want to introduce a responsive enumeration, you must create an adapter interface IResponseHandler

using a type method GenerateViewForResponse

and provide a concrete implementation that consumes the ValidateHashResponses enumeration.