<p>I may have gone down a long and twisted rabbit hole trying to figure out this problem, but I learned a lot about how model binding along the way, so I consider the whole experiment a productive use of my time, even if I end up ripping it all out in a few weeks. However, since I thought this would be a good idea, I figure others might find a good use for this knowledge. Thus, this is how I am using an explicity constructor when the input is in a <code>JSON</code> format and parameter is bound using the request body.</p>
<pre><code>[HttpPost]
public IActionResult Create([FromBody]CreatePatron command)
</code></pre>
<p>An early lesson when writing Actions is that, in Core MVC, the <code>[FromBody]</code> attribute is required to use the <code>JsonInputFormatter</code>. Setting a new convention for controllers is possible (<a href="http://www.dotnetcurry.com/aspnet-mvc/1149/convert-aspnet-webapi2-aspnet5-mvc6">instructions on how to</a>), but for now I am going to stick with the tedium of remembering to apply it to every parameter.</p>
<p>The purpose of this is that I want the <code>GeneratedBy</code> and the <code>GeneratedOn</code> parameters to be required for every instance of a <code>Command</code>. This ensures that it won't be set by the user (either the end user or another user in a consuming change) since the properties' set methods are <code>protected</code>.</p>
<pre><code>using System;

namespace Vigil.Domain.Messaging
{
    public abstract class Command : KeyIdentity, ICommand
    {
        public string GeneratedBy { get; protected set; }
        public DateTime GeneratedOn { get; protected set; }

        protected Command(string generatedBy, DateTime generatedOnUtc)
        {
            if (string.IsNullOrEmpty(generatedBy)) throw new ArgumentNullException(nameof(generatedBy));
            if (generatedOnUtc == default(DateTime)) throw new ArgumentException($"{nameof(generatedOnUtc)} requires a non-default value.", nameof(generatedOnUtc));
            if (generatedOnUtc.Kind != DateTimeKind.Utc) throw new ArgumentException($"{nameof(generatedOnUtc)} must be DateTimeKind.UTC.", nameof(generatedOnUtc));

            GeneratedBy = generatedBy;
            GeneratedOn = generatedOnUtc;
        }
    }
}
</code></pre>
<p>This poses a problem with using the <code>CreatePatron</code> command as a parameter. The default <a href="https://github.com/aspnet/Mvc/blob/dev/src/Microsoft.AspNetCore.Mvc.Formatters.Json/JsonInputFormatter.cs"><code>JsonInputFormatter</code> class</a> uses the <a href="https://github.com/aspnet/Mvc/blob/dev/src/Microsoft.AspNetCore.Mvc.Formatters.Json/JsonInputFormatter.cs#L149"><code>JsonSerializer.Deserialize(JsonTextReader, Type)</code> method</a> to create the instance of the model. This method uses the parameterless constructor, which my objects to not have. To solve this problem, I inheritted from the <code>JsonInputFormatter</code> (keeping as much functionality as I could) and proceeded from there.</p>
<h2>CommandInputFormatter Constructor</h2>
<p>All of the fields that are passed to the <code>JsonInputFormatter</code> constructor are stored as private readonly fields. Therefore, I had to create my own private readonly copies of them to use in the methods that I needed to write.</p>
<pre><code>public class CommandInputFormatter : JsonInputFormatter
{
    private readonly IArrayPool&#x3C;char> _charPool;
    private readonly ILogger _logger;
    private readonly ObjectPoolProvider _objectPoolProvider;

    public CommandInputFormatter(ILogger logger
        , JsonSerializerSettings serializerSettings
        , ArrayPool&#x3C;char> charPool
        , ObjectPoolProvider objectPoolProvider)
        : base(logger, serializerSettings, charPool, objectPoolProvider)
    {
        if (charPool == null)
        {
            throw new ArgumentNullException(nameof(charPool));
        }
        _charPool = new JsonArrayPool&#x3C;char>(charPool);

        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
        _objectPoolProvider = objectPoolProvider ?? throw new ArgumentNullException(nameof(objectPoolProvider));
    }
}
</code></pre>
<h2>CommandInputFormatter.CanReadyType</h2>
<p>Since I wanted this formatter to only work for these specific classes, I extended the functionality of the <code>CanReadType</code> method to also filter for just models that implement the <code>Command</code> abstract base class.</p>
<pre><code>protected override bool CanReadType(Type type)
{
    return base.CanReadType(type) &#x26;&#x26; typeof(Command).IsAssignableFrom(type);
}
</code></pre>
<h2>CommandInputFormatter.ReadRequestBodyAsync</h2>
<p>The simplest way for me to change the constructor that <code>JsonInputFormatter</code> uses to generate the model would have been if they had isolated that small piece of the <code>ReadRequestBodyAsync</code> method into its own protected virtual method. However, since they didn't, I have to override the entire thing. Because ASP.NET Core (including MVC) is all open source, I was able to copy the source code from the original and only replace the parts that I needed to.</p>
<pre><code>public override Task&#x3C;InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context, Encoding encoding)
{
    if (context == null)
    {
        throw new ArgumentNullException(nameof(context));
    }
    if (encoding == null)
    {
        throw new ArgumentNullException(nameof(encoding));
    }


    using (var streamReader = context.ReaderFactory(context.HttpContext.Request.Body, encoding))
    {
        using (var jsonReader = new JsonTextReader(streamReader))
        {
            jsonReader.ArrayPool = _charPool;
            jsonReader.CloseInput = false;

            var successful = true;
            EventHandler&#x3C;Newtonsoft.Json.Serialization.ErrorEventArgs> errorHandler = (sender, eventArgs) =>
            {
                successful = false;

                var exception = eventArgs.ErrorContext.Error;

                // Handle path combinations such as "" + "Property", "Parent" + "Property", or "Parent" + "[12]".
                var key = eventArgs.ErrorContext.Path;
                if (!string.IsNullOrEmpty(context.ModelName))
                {
                    if (string.IsNullOrEmpty(eventArgs.ErrorContext.Path))
                    {
                        key = context.ModelName;
                    }
                    else if (eventArgs.ErrorContext.Path[0] == '[')
                    {
                        key = context.ModelName + eventArgs.ErrorContext.Path;
                    }
                    else
                    {
                        key = context.ModelName + "." + eventArgs.ErrorContext.Path;
                    }
                }

                var metadata = GetPathMetadata(context.Metadata, eventArgs.ErrorContext.Path);
                context.ModelState.TryAddModelError(key, eventArgs.ErrorContext.Error, metadata);

                _logger.LogDebug(1, eventArgs.ErrorContext.Error, "Command Input Formatter threw an exception");

                // Error must always be marked as handled
                // Failure to do so can cause the exception to be rethrown at every recursive level and
                // overflow the stack for x64 CLR processes
                eventArgs.ErrorContext.Handled = true;
            };

            object model = GetModel(context);
            var type = context.ModelType;
            var jsonSerializer = CreateJsonSerializer();
            jsonSerializer.Error += errorHandler;
            try
            {
                jsonSerializer.Populate(jsonReader, model);
            }
            finally
            {
                // Clean up the error handler since CreateJsonSerializer() pools instances.
                jsonSerializer.Error -= errorHandler;
                ReleaseJsonSerializer(jsonSerializer);
            }

            if (successful)
            {
                return InputFormatterResult.SuccessAsync(model);
            }

            return InputFormatterResult.FailureAsync();
        }
    }
}
</code></pre>
<p>There are only two lines that differ between the formatters; I was surprised by how little I had to change.</p>
<p>| <code>JsonInputFormatter</code>                                | <code>CommandInputFormatter</code>                   |
|-----------------------------------------------------|-------------------------------------------|
|object model;                                        |object model = GetModel(context);          |
|model = jsonSerializer.Deserialize(jsonReader, type);|jsonSerializer.Populate(jsonReader, model);|</p>
<h2>CommandInputFormatter.GetModel</h2>
<p>Of course, there was a little more that I had to add, but this piece is very specific to my application. This is the block of code that creates the appropriate <code>Command</code> object using the explicit constructor.</p>
<pre><code>private static readonly Dictionary&#x3C;Type, Func&#x3C;string, DateTime, Command>> _commandModelCreators = new Dictionary&#x3C;Type, Func&#x3C;string, DateTime, Command>>();
protected virtual object GetModel(InputFormatterContext context)
{
    if (!_commandModelCreators.ContainsKey(context.ModelType))
    {
        var generatedBy = Expression.Parameter(typeof(string), nameof(Command.GeneratedBy));
        var generatedOn = Expression.Parameter(typeof(DateTime), nameof(Command.GeneratedOn));
        var constructor = context.ModelType.GetConstructor(new Type[] { typeof(string), typeof(DateTime) });
        var newExpr = Expression.New(constructor, generatedBy, generatedOn);
        var lambda = Expression.Lambda&#x3C;Func&#x3C;string, DateTime, Command>>(newExpr, generatedBy, generatedOn);

        _commandModelCreators.Add(context.ModelType, lambda.Compile());
    }
    // @TODO Find a better way to get the current user's name
    return _commandModelCreators[context.ModelType](context?.HttpContext?.User?.Identity?.Name ?? "Anonymous User", DateTime.UtcNow);
}
</code></pre>
<p>I save the compiled expression in the formatter. There might be a better way to cache the results, but I can worry about that optimization later. I would also like to have a better way to pass in the identity of the user generating this command. This works for my testing purposes, but I need a better way to do this in the future. Additionally, it would be better if I could inject the <code>DateTime.UtcNow</code> value to be able to explicitly set it and test again in unit tests.</p>
<h2>Include the CommandInputFormatter</h2>
<p>I was not expecting this piece to turn into a three step process. In order to add an an input formatter with parameters, it needs to be configured through an <code>IConfigureOptions&#x3C;MvcOptions></code>, which is added via a <code>ServiceDescriptor</code> to the <code>Services</code> collection on the <code>IMvcBuilder</code> in the <code>Startup</code> class. I learned all this by searching through the Github repository. Once I found the path through it all, I just duplicated most of it, adapting it to my use case.</p>
<p>The <code>IConfigureOptions&#x3C;MvcOptions></code> is easy to implement. The difficulty was in finding what dependency injections were available for the constructor.</p>
<pre><code>public class VigilMvcOptionsSetup : IConfigureOptions&#x3C;MvcOptions>
{
    private readonly ILoggerFactory _loggerFactory;
    private readonly JsonSerializerSettings _jsonSerializerSettings;
    private readonly ArrayPool&#x3C;char> _charPool;
    private readonly ObjectPoolProvider _objectPoolProvider;

    public VigilMvcOptionsSetup(
        ILoggerFactory loggerFactory,
        IOptions&#x3C;MvcJsonOptions> jsonOptions,
        ArrayPool&#x3C;char> charPool,
        ObjectPoolProvider objectPoolProvider)
    {
        if (jsonOptions == null)
        {
            throw new ArgumentNullException(nameof(jsonOptions));
        }

        _loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
        _jsonSerializerSettings = jsonOptions.Value.SerializerSettings;
        _charPool = charPool ?? throw new ArgumentNullException(nameof(charPool));
        _objectPoolProvider = objectPoolProvider ?? throw new ArgumentNullException(nameof(objectPoolProvider));
    }

    public void Configure(MvcOptions options)
    {
        options.InputFormatters.Insert(0, new CommandInputFormatter(
            _loggerFactory.CreateLogger&#x3C;CommandInputFormatter>(),
            _jsonSerializerSettings,
            _charPool,
            _objectPoolProvider
        ));
    }
}
</code></pre>
<p>From here, I could have easily just injected the <code>VigilMvcOptionsSetup</code> during startup config. I suspect that there will be more customization that I will want to attach to the <code>IMvcBuilder</code>, so chose to follow the lead from the MVC developers and create an extension method.</p>
<pre><code>public static class MvcBuilderExtensions
{
    public static IMvcBuilder AddCommandFormatter(this IMvcBuilder builder)
    {
        if (builder == null)
        {
            throw new ArgumentNullException(nameof(builder));
        }
        ServiceDescriptor descriptor = ServiceDescriptor.Transient&#x3C;IConfigureOptions&#x3C;MvcOptions>, VigilMvcOptionsSetup>();
        builder.Services.TryAddEnumerable(descriptor);
        return builder;
    }
}
</code></pre>
<p>The final step, to wire it all together, is to add a call to the extension method in the <code>Startup.ConfigureServices(IServiceCollection)</code> method. It is important that my extension method comes after the <code>AddMvc</code> method because I inject the <code>CommandInputFormatter</code> to the beginning of the <code>InputFormatters</code> collection. Reversing the order would put my input formatter behind all of the defaults, and the <code>JsonInputFormatter</code> would grab all of the requests before my input formatter was ever checked.</p>
<pre><code>// Add framework services.
services.AddMvc()
    .AddCommandFormatter();
</code></pre>


Rovani's Sandbox

hastobeabetterway

Using an Explicit Model Constructor with a JsonInputFormatter