One of the things that I have never been happy with on any project I have worked on over the years and have really not been able to resolve myself is exactly at what tier in an application should
human readable error information be retrieved for display to
a user.
A common approach that has worked well has been to return strongly typed/concrete "result objects" from the methods on the public surface of the business tier/API.
A method on the interface may be:
public ClearUserAccountsResult ClearUserAccounts(ClearUserAccountsParam param);
And the result class implementation:
public class ClearUserAccountsResult : IResult
{
public readonly List<Account> ClearedAccounts{get; set;}
public readonly bool Success {get; set;} // Implements IResult
public readonly string Message{get; set;} // Implements IResult,
human readable
// Constructor implemented here to set readonly properties...
}
This works great when the API needs to be exposed over WCF as the result object can be serialized. Again this is only done on the public surface of the API/business tier. The error message can also be looked up from the database, which means it can be changed and localized.
However, it has always been suspect to me, this idea of returning
human readable information from the business tier like this, partly because what constitutes the public surface of the API may change over time...and it may be the case that the API will need to be reused by other API components in the future that do not need the
human readable string messages (and looking them up from
a database would be an expensive waste).
I am thinking
a better approach is to keep the business objects free from such result objects and keep them simple and then retrieve
human readable error strings somewhere closer to the UI layer or only in the UI itself, but I have two problems here:
1) The UI may be
a remote client (Winforms/WPF/Silverlight) or an ASP.NET web application hosted on another server. In these cases the UI will have to fetch the error strings from the server.
2) Often there are multiple legitimate modes of failure. If the business tier becomes so vague and generic in the way it returns errors there may not be enough information exposed publicly to tell what the error actually was: i.e: if
a method has 3 modes of legitimate failure but returns
a boolean to indicate failure, you cannot work out what the appropriate message to display to the user should be.
I have thought about using failure enums as
a substitute, they can indicate
a specific error that can be tested for and coded against. This is sometimes useful within the business tier itself as
a way of passing via method returns the specifics of
a failure rather than just
a boolean, but it is not so good for serialization scenarios.
Is there
a well worn pattern for this? What do people think?
Thanks.
