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.
