Design and Architecture

// Service layer
class PersonService
{
    Person Load(int id)
    {
        // Validate ID is greater than 0
        PersonManager mgr = new PersonManager();
        Person person = mgr.GetByID(id);

        return person;
    }

    void Save(Person person)
    {
        PersonManager mgr = new PersonManager();
        
        if (person.ID <= 0)
        {
            mgr.Insert(person);
        }
        else
        {
            mgr.Update(person);
        }
    }
}

// Business Layer
class Person
{
    int ID { get; set; }
    string Name { get; set; }
}

// Data Access Layer
class PersonManager // This is really a 'Repository' (http://blogs.hibernatingrhinos.com/nhibernate/archive/2008/10/08/the-repository-pattern.aspx)
{
    Person GetByID(int id)
    {
        // Load a person object from the database
    }

    void Update(Person person)
    {
        // Update a person in the database
    }

    Person Insert(Person person)
    {
        // Insert a person into the database, returning the person with an updated Key (ID in this case)
    }

    void Delete(Person person)
    {
        // Delete a person from the database
    }
}

// API - This is shared between all layers
interface IRepository<t>
{
    T GetByID(int id);
    T Insert(T item);
    void Update(T item);
    void Delete(T item);
}

class DataAccessException: ApplicationException
{
    // ...
}

class BusinessException: ApplicationException
{
    // ...
}

class PresentationException: ApplicationException
{
    // ...
}

// Service layer - Primary exception handling here
class PersonService
{
    public PersonService(IRepository<person> repository)
    {
        _repository = repository;  // Inject the repository, so it can be mocked when you unit test PersonService
    }

    private IRepositoru<person> _repository;

    Person Load(int id)
    {
        // Always throw ArgumentExceptions for parameter validations, rather than BusinessExceptions
        if (id <= 0) throw new ArgumentException("The Person ID must be greater than zero."); 

        try
        {
            Person person = _repository.GetByID(id);
            return person;
        }
        catch (DataAccessException ex)
        {
            throw new BusinessException("An error occurred while accessing data.", ex);
        }
        catch (ArgumentNullException ex)
        {
            throw ex;
        }
        catch (ArgumentException ex)
        {
            throw ex;
        }
        catch (Exception ex)
        {
            throw new BusinessException("An error occurred while processing your request.", ex);
        }
    }

    void Save(Person person)
    {
        if (person == null) throw new ArgumentNullException("person");
        
        try
        {
            if (person.ID <= 0)
            {
                _repository.Insert(person);
            }
            else
            {
                _repository.Update(person);
            }
        }
        catch (DataAccessException ex)
        {
            throw new BusinessException("An error occurred while updating data.", ex);
        }
        catch (ArgumentNullException ex)
        {
            throw ex;
        }
        catch (ArgumentException ex)
        {
            throw ex;
        }
        catch (Exception ex)
        {
            throw new BusinessException("An error occurred while processing your request.", ex);
        }
    }
}

// Business Layer - Just data and basic behavior here
class Person
{
    int ID { get; set; }
    string Name { get; set; }
}

// Data Access Layer - Handle all data management here
class PersonRepository: IRepository<person> // Implements IRepository<t> from API
{
    Person GetByID(int id)
    {
        if (id <= 0) throw new ArgumentException("The ID must be greater than zero.");

        try
        {
            // Load a person object from the database
        }
        catch (Exception ex)
        {
            throw new DataAccessException(
                String.Format("An error occurred retrieving the requested Person: {0}", id), ex
            );
        }
    }

    void Update(Person person)
    {
        if (person == null) throw new ArgumentNullException(person);

        try
        {
            // Update a person in the database
        }
        catch (Exception ex)
        {
            throw new DataAccessException(
                String.Format("An error occurred updating an existing Person: {0}", person.ID), ex
        }
    }

    Person Insert(Person person)
    {
        if (person == null) throw new ArgumentNullException(person);

        try
        {
            // Insert a person into the database, returning the person with an updated Key (ID in this case)
        }
        catch (Exception ex)
        {
            throw new DataAccessException(
                "An error occurred inserting a new Person.", ex 
            );
        }
    }

    void Delete(Person person)
    {
        if (person == null) throw new ArgumentNullException(person);

        try
        {
            // Delete a person from the database
        }
        catch (Exception ex)
        {
            throw new DataAccessException(
                String.Format("An error occurred deleting an existing Person: {0}", person.ID), ex
            );
        }
    }
}
</t></person></person></person></t>

public class Person
{
    public DateTime Birthdate { get{ ... something secret ... } }
    public int Age { get { ... something secret ... } }
}

try
{
    ... exception thrown here ...
}
catch(Exception e)
{
    if(null != e.InnerException)
    {
        if(e.InnerException is SqlException)
        {
            ... do something SqlException specific here ...
        }
    }
}

Leftyfarrell wrote:

the DALUser class doesn't really do much... so it is still worth unit testing?

// Service layer (business component, contains logic)
class UserService
{
   IDataMapper<User> _mapper;

   public UserService(IDataMapper<User> mapper)
   {
       _mapper = mapper; // Inject mapper into service
   }

   // Operations to load, save, and work with users,
   // orchestrating interations between UserDAL and User

   public User Load(int id) { //... }
   public void Save(User user) { //... }
}

// Entity layer (business object, contains data)
class User
{
   int ID { get; set; }
   // Contains user data
}

// Data Access layer
interface IDataMapper<T>
{
    T GetByID(int id);
    T Insert(T item);
    void Update(T item);
    void DeletE(T item);
}

class UserDAL: IDataMapper<User>
{
   // Implements IDataMapper for User...this COMPLETELY abstracts 
   // data access logic from the business objects and components,
   // so all they have to do is get, insert, update, and delete 
   // without caring at all how its done...exactly how it should be
}

class MockUserDAL: IDataMapper<User>
{
    // Implements a mock version of IDataMapper for User...returning canned results
}

[TestMethod]
public void Test_UserService_Load
{
    MockUserDAL userDal = new MockUserDAL();

    UserService userSvc = new UserService(userDal);

    User user = userSvc.Load(1);

    Assert.IsNotNull(user);
    Assert.AreEqual(1, user.ID);
}