Question

I am trying to code with best practices and I have a doubt here. I am testing this on WebForms.

I have a UserService Layer where I have a method to pass a user to the RepositoryLayer:

public AddUserResponse AddUserResponse(AddUserRequest addUserRequest)         
{
  AddUserResponse response = new AddUserResponse();
  User objUser = new User();

  objUser.Names = addUserRequest.Names;
  objUser.LastName = addUserRequest.LastName;
  objUser.Email  = addUserRequest.Email;
  objUser.Alias  = addUserRequest.Alias;
  objUser.Profile.IdProfile = addUserRequest.Profile.IdProfile;
  objUser.Password = addUserRequest.Password;
  objUser.Active = addUserRequest.Active;

  short OperationState=_userRepository.Add(objUser);        
  if (OperationState==0)  
  {
    response.State=true;
    response.Message="User inserted";
  }
  else if (OperationState==2)
  {
    response.State=false;
    response.Message="Alias or Email already exist. Cannot insert User";
  }
  else 
  {
    response.State=false;
    response.Message="Error in User insertion";
  }       

  return response;           
}

Then I have a UserRepository Layer where I have a function that Adds a user comming from my service layer:

public short Add(User objUser)
    { ...  return OperationState  }

As showed this function relays on a stored procedure call to insert the user record. If the user email or alias doesn’t exist then it inserts and returns 0, if it does returns 2, and if the operation fails returns 1.

I perform the checking and insertion in one call to save database round trips.

Am I performing the checking in a correct way on my service and repository classes?, or if am not, How should I abstract the logic to let the system determine when is a duplicated user?. Should I use the model or service to put the validation logic and raise a custom exception when that happens?

Thanks a lot for your insight.

UPDATE

For general interest I am posting now how I am implementing this on my App, once I get the Jason’s IoC solution gonna make an update on this as well.

Model Class:

using ABC.DEF.Infrastructure.Domain;

namespace ABC.DEF.Model
{   
    public class AliasOrEmailAreUnique
    {
        private readonly IRepository<User, int> repository;

        public AliasOrEmailAreUnique(IRepository<User,int> repository) 
        {
            this.repository = repository;
        }

        //If the user is added has Id 0 so search among all the existing users for one that could have the alias or email registered already    
        //else if the user is being edit then search among all the user except the user with such Id(itself)
        public bool IsBroken(User model) 
        {
            if (model.IdUser == 0)
            {
                return (
                repository.List().Where(x => x.Alias == model.Alias).Any()
                || repository.List().Where(x => x.Email == model.Email).Any()
                );
            }
            else 
            {
                return (
                repository.List().Where(x => x.Alias == model.Alias && x.IdUser != model.IdUser).Any()                    
                || repository.List().Where(x => x.Email == model.Email && x.IdUser != model.IdUser).Any()
                );
            }


        }

        public ErrorMessage ErrorMessage
        { 
          get { return new ErrorMessage { Property = "AliasEmail", Message = "Alias or Email exists already" }; } 
        }
    }
}

Service Class:

using ABC.DEF.Repository;
using ABC.DEF.Model;
using ABC.DEF.Service.Messaging.User;

namespace ABC.DEF.Service
{
    public class UsuarioService
    {
        public AddUserResponse AddUserResponse(AddUserRequest addUserRequest)         
        {
            AddUserResponse response = new AddUserResponse();
            User objUser = new User();

            objUser.Names = addUserRequest.Names;
            objUser.LastName = addUserRequest.LastName;
            objUser.Email  = addUserRequest.Email;
            objUser.Alias  = addUserRequest.Alias;
            objUser.Profile.IdProfile = addUserRequest.Profile.IdProfile;
            objUser.Password = addUserRequest.Password;
            objUser.Active = addUserRequest.Active;


            //Determine if the Alias or Email are unique
            Model.AliasOrEmailAreUnique aliasOrEmailAreUnique = new Model.AliasOrEmailAreUnique(_userRepository);

            if (!aliasOrEmailAreUnique.IsBroken(objUser))
            {
            _usuarioRepository.Add(objUser);
            response.State = true;
            response.Message = "User added succesfully";
            }
            else
            {
            response.State = false;
            response.Message = aliasOrEmailAreUnique.ErrorMessage.Message;
         }

         return response;           
      }
   }

}

Answer 1

I like to validate the input at the beginning of a unit of work. For a web application the request is the unit of work. before the controller action is fired I validate the user input. the action itself is the “happy path”. if it makes it this far I know my operation will succeed. at the end the request (the response) I commit any changes back to the database.

I also like to keep my operation explicit so a call to add an entity would be different than call to edit an entity vs. deleting an entity.

in your scenario you have a service layer rather than controller actions, but the process is still the same. validate the model before calling the service layer. then pass the model to the service layer to preform what operations you want.

…UPDATE 1…

in response to your comment below…..

I have been calling my repositories only in the service layer

Becareful not to fall into the trap of thinking there is a linear patterns for making calls. through the application. instead think of it as an onion or sphere with multiple layers.

The model is just a POCO/DTO. there would be other components responsible for validating the model. typically I have a business rules engine that looks something like this… written off the top of my head.

interface IRule<T>
{
     bool IsBroken(T model);
     ErrorMessage Message {get;}
}

interface IRulesEngine
{
     IEnumerable<ErrorMessage> Validate<T>(T model);
}

class ErrorMessage
{
      public string Property {get;set;}
      public string Message {get;set;}
}

class RulesEngine : IRulesEngine
{
     private readonly IContainer container;
     public RulesEngine(IContainer container)
     {
          this.container = container;
     }

     public IEnumerable<ErrorMessage> Validate<T>(T model)
     {
           return container
                     .GetInstances<IRule<T>>()
                     .Where(rule => rule.IsBroken(model))
                     .Select(rule =>  rule.Message);
     }
}

this implementation assumes an IoC container, but can be implemented without one. The a rule may look like this

class NameIsUnique<MyClass> : IRule<MyClass>
{
     private readonly IRepository<TheEntity> repository;

     public NameIsUnique<MyClass>(IRepository<TheEntity> repository)
     {
         this.repository = repository;
     }

     public bool IsBroken(MyClass model)
     {
          return repository.Where(x => x.Name == model.Name).Any();
     }

     public ErrorMessage 
     { 
         get { return new ErrorMessage { Property = "Name", Message = "Name is not unique" }; } 
     }
}

finally, how this can be used.

var errors = engine.Validate(model);
LoadErrorsInToView(errors);
if(errors.Any()) return;

//call service to process the happy path...

…UPDATE 2…

first we refactor our interfaces

//this is just a marker interface. don't directly imeplement this.
interface IRule
{
}

interface IRule<T> : IRule
{
    bool IsBroken(T model);
    ErrorMessage Message {get;}
}

class RulesEngine : IRulesEngine
{
    public reasdonly ICollection<IRule> Rules = new List<IRule>();

    public IEnumerable<ErrorMessage> Validate<T>(T model)
    {
       return Rules
                 .Where(x => typeof(IRule<T>).IsAssignableFrom(x.GetType()))
                 .Cast<IRule<T>>()
                 .Where(rule => rule.IsBroken(model))
                 .Select(rule =>  rule.Message);
    }
}