Question

I have 3 action name delete on 3 different controllers which are on “registration,profile and questions” they all have action delete methods. How can I from my registration-delete method call out profile-delete and questions-delete . That way when a user wants to delete their account all they have to do is go on registration-delete instead of going on registration,profile and questions delete methods. I want in 1 [HttpPost, ActionName(“Delete”)](registration) to call out the other 2 ActionName(“Delete”) methods as i prefer people to delete everything in one place is this possible? assuming that each user shares a unique ID that is the same all across. The comment in the code im just using to illustrate any help would be great

registration-delete below

  [HttpPost, ActionName("Delete")]
    public ActionResult DeleteConfirmed()
    {
        var ss = User.Identity.Name;
        var getid = (from s in db.registration where ss == s.email select s.RegistrationID).FirstOrDefault();
        registration registration = db.registration.Find(getid);
//This delete's the registration
        db.buyers.Remove(registration);

// How can i call-out profile-delete actionname here and questions-delete like
//if (question-delete != null){
// include  ActionResult deleteconfirmed("question-delete" }

        db.SaveChanges();
        return RedirectToAction("logout");
    }

Answer 1

If I understand your question, you are asking to call other controller’s action method from the currently executing action method? You typically would not do that. The first rule of Controller’s action methods is: no action method should be more than 10 lines of code. Basically, an action method is really supposed to be a simple method to collect a view, or call an action in your domain, and return.

In other words, the SRP pattern:
http://codebetter.com/karlseguin/2008/12/05/get-solid-single-responsibility-principle/

Instead, you would organize your Domain-logic (what you describe is considered domain model logic, not controller logic) for this repetitive code such as deleting questions here, but when user is deleted also delete questions, etc.

// an example of IOC injection of your IUserService
private IUserService
public RegistrationController(IUserService userService)
{
    _userService = userService;
}

[HttpPost]
public ActionResult Delete()
{

    // insert modelstate and/or validation logic
    //
    if (User.Identity.IsAuthenticated == false)
    {
        return RedirectToAction("index", "Home");
    }

    // good practice to never bubble up exceptions to users
    try 
    {
        if (_userService.DeleteByEmail(User.Identity.Name) == false)
        {
            ModalState.AddModelError(String.Empty, "Not allowed?");
            return View();
        }

        // save it all in a single atomic operation here to keep it all in
        // a single Transaction Scope that will rollback properly if there is
        // an error.
        //
        db.SaveChanges();
    }
    catch (Exception)
    {
        ModalState.AddModelError(String.Empty, "An error occurred...");
        return View();
    }

    // all ok!
    return RedirectToAction("logout");
}

Notice how clean this action method is. It just gets down to business with a single line of code or two, and a whole bunch of exit paths to handle the user’s experience properly in many different situations.

Now, your domain logic can be encapsulated into a service (or provider, or alike):

namespace MyWebsite.Models
{
public class UserService : IUserService
{
    // Todo: convert to some IoC lovin'
    //

    public Boolean DeleteByEmail(String email)
    {

        var user = 
            (from user in db.Registrations 
             where 
                 user.Email == email
             select s).FirstOrDefault();

         if (user == null)
             return false;

         // call into other services to delete them
         ProfileDataService.DeleteByUserId(user.UserId);
         QuestionsService.DeleteByUserId(user.UserId);

         // finally, delete the user
         db.Registrations.Delete(user);

         // note, I am NOT calling db.SaveChanges() here.  Look
         // back at the controller method for the atomic operation.
         //

         return true;
    }
}
}

This can be implemented 100s of different ways. The point being is to abstract that logic out to a common code base, or “Domain”. I chose to put that logic in your current Website namespace under Models as a shortcut in this example.

As for your other Delete() methods on your other controllers, you would just call into a QuestionsService.DeleteByUserId() and ProfileDataService.DeleteByUserId() to handle those. You can even share those services across the domain, as I showed above.