I want to write many GET handlers that receive an ID for an object,

site.com/controller/Action1/1234
site.com/controller/Action2/1234
site.com/controller/Action3/1234

I would like to write the code that fetches the complex object from the DB just once:

class ComplexObject
{
    public string str1 { get; set; }
    public string str2 { get; set; }
}

ComplexObject GetFromId(string id)
{
    ComplexObject x = Database.GetById(id);

    if (x == null)
    {
        return Http404();
    }

    return x;
}

and then just use the object directly:

[Route("/[controller]/[action]/{message}")]
[HttpGet]
public string Action1(ComplexObject message)
{
    return message.str1;
}

[Route("/[controller]/[action]/{message}")]
[HttpGet]
public string Action2(ComplexObject message)
{
    return message.str1;
}

[Route("/[controller]/[action]/{message}")]
[HttpGet]
public string Action3(ComplexObject message)
{
    return message.str1;
}

And that all of my handlers will just get the object, and won't have to check whether the ID is correct, etc.

How is that possible?

CodePudding user response：

The official Microsoft Docs describe exactly how you can bind route parameters to a complex object from a database using a custom model binder.

Here's their example model binder:

public class AuthorEntityBinder : IModelBinder
{
    private readonly AuthorContext _context;

    public AuthorEntityBinder(AuthorContext context)
    {
        _context = context;
    }

    public Task BindModelAsync(ModelBindingContext bindingContext)
    {
        if (bindingContext == null)
        {
            throw new ArgumentNullException(nameof(bindingContext));
        }

        var modelName = bindingContext.ModelName;

        // Try to fetch the value of the argument by name
        var valueProviderResult = bindingContext.ValueProvider.GetValue(modelName);

        if (valueProviderResult == ValueProviderResult.None)
        {
            return Task.CompletedTask;
        }

        bindingContext.ModelState.SetModelValue(modelName, valueProviderResult);

        var value = valueProviderResult.FirstValue;

        // Check if the argument value is null or empty
        if (string.IsNullOrEmpty(value))
        {
            return Task.CompletedTask;
        }

        if (!int.TryParse(value, out var id))
        {
            // Non-integer arguments result in model state errors
            bindingContext.ModelState.TryAddModelError(
                modelName, "Author Id must be an integer.");

            return Task.CompletedTask;
        }

        // Model will be null if not found, including for
        // out of range id values (0, -3, etc.)
        var model = _context.Authors.Find(id);
        bindingContext.Result = ModelBindingResult.Success(model);
        return Task.CompletedTask;
    }
}

And then there are various ways to use this new model binder. One is to add an attribute on the model itself:

[ModelBinder(BinderType = typeof(AuthorEntityBinder))]
public class Author
{
    // snip
}

Another is to use an attribute on the action parameters:

[HttpGet("{id}")]
public IActionResult GetById([ModelBinder(Name = "id")] Author author)
{
    // snip
}

CodePudding user response：

I am not sure why one would want to do what you are proposing, but it unnecessarily overcomplicates things and causes dependencies on the model binder.

Here is how I would implement this:

Have a class that manages your complex object and hide it behind an interface, the inject it into the controller:

public interface IComplexObjectManager 
{
    ComplexObject GetFromId(string id);
}

public class ComplexObjectManager : IComplexObjectManager 
{
    private readonly Database _database;
    
    public ComplexObjectManager(Database database)
    {
        _database = database;
    }

    public ComplexObject GetFromId(string id)
    {
        ComplexObject x = _database.GetById(id);            
        return x;
    }
}

[ApiController]
public class ComplexObjectController
{
    public ComplexObjectController(IComplexObjectManager complexObjectManager)
    {
        ObjectManager = complexObjectManager;
    }

    public IComplexObjectManager ObjectManager { get; }
}

Then consume it in your method, changing the return type to an action result:

[Route("/[controller]/[action]/{id}")]
[HttpGet]
public IActionResult Action1(string id)
{
    var obj = ObjectManager.GetFromId(id);
    if(obj != null)
        return Ok(obj.str1);
    else
        return NotFound();
}

Make sure to handle the response accordingly.

This approach decouples things (further abstraction can be added for Database), and allows for injection and unit testing.

Please check the code for consistency. I wrote this in a hurry.

CodePudding user response：

I'm not doing the exactly thing that you are asking but i think it can help you. First of all, i'm using BaseController for it because you can filter your all actions before they are getting executed.

public class BaseController : Controller
{
    #region /*IoC*/
    public BaseViewModel baseViewModel;
    public IUnitOfWork<Product> unitOfWorkProductForCart;
    #endregion

    #region /*ctor*/
    public BaseController(IUnitOfWork<Product> unitOfWorkProductForCart)
    {
        this.unitOfWorkProduct = unitOfWorkProduct;
    }
    #endregion

    public override void OnActionExecuting(ActionExecutingContext filterContext)
    {
        string controllerName = filterContext.ActionDescriptor.RouteValues["controller"];
        string actionName = filterContext.ActionDescriptor.RouteValues["action"];
        if (actionName == "ProductDetails")
        {
            var urlParameters = filterContext.ActionArguments;
            if (urlParameters.Count != 0)
            {
                var isThatSlug = urlParameters.ElementAt(0).Key;
                if (isThatSlug == "slug")
                {
                    var slugCondition = urlParameters.ElementAt(0).Value;
                    var isThatProductExist = unitOfWorkProduct.RepositoryProduct.GetProductBySlugForChecking(slugCondition.ToString());
                    if (isThatProductExist.Count == 0)
                    {
                        filterContext.Result = new RedirectToRouteResult(new RouteValueDictionary
                            {
                                {"controller","Account"},
                                {"action","NotFound"}
                            });
                    }
                }
            }
        }
    }
}

in that example, i'm controlling the parameters. if it's something like i don't want, it's redirects you to the NotFound page. i hope it can give you a idea