Which of these error handling patterns is more efficient?

Question

I'm working on a cleanup of some older apex code, and I've noticed two distinct patterns being used to handle errors when saving records.

One uses a try-catch block to try to update the records, and displays the exception to the page if any is caught.

try {
    update accounts;
} catch (Exception e) {
    ApexPages.addMessages(e);
}

The other uses the Database class to get a result, and then iterates over the results of a insert/update operation and displays the error onto the page.

Database.SaveResult result = Database.Update(accounts, true); 

if (!result.isSuccess()) {
    for (Database.Error err:result.getErrors()) {
        ApexPages.addMessage(new ApexPages.message(ApexPages.Severity.ERROR, err.getMessage()));
    }
}

Which of these two patterns is more efficient?

Answer 1

I wouldn't necessarily say that one is more "efficient" than the other. It's more a matter of what the author wanted the code to accomplish. The first method will only add one message to send to a page while the latter will add a message for each record that isn't saved.

What do you want to accomplish with your code and convey to the user? Is your code in a trigger, a class of some kind, or is it in a controller for a visualforce page? The location of the code would impact the choice one might make. I don't believe the answer to your question is merely one of efficiency.

Answer 2

In addition to the addMessages I also create an exception record, because if It isn't an error that should be a hard stop I still may want to know what broke. This requires a new custom object, I call it Exception

public with sharing class BusinessException extends Exception
{
public static void recordError(String fileName, String methodName, String errorMessage)
{
        Exceptions__c newException = createError(fileName, methodName, errorMessage);
        insertError(newException);          
 }

private static Exceptions__c createError(String fileName, String methodName, String errorMessage)
{
    Exceptions__c result = new Exceptions__c();
    result.FileName__c = fileName;
    result.MethodName__c = methodName;
    result.SystemError__c = errorMessage;

    return result;
}

private static void insertError(Exceptions__c oopsey)
{
    try
    {
        insert oopsey;
    }
    catch(DMLException dmlError)
    {

    }
   }
}

Then when you build your Try/Catch, whatever what you decide on you can capture that failure in your new object. I do a ton of Callouts and would be lost without this pattern

 try
    {     
       //something      
    }
    catch(QueryException error)
    {

        BusinessException.recordError('File_Name', 'Method Name', error);
    }   

Answer 3

This test page:

<apex:page controller="MyController">
    <apex:pageMessages/>
    <apex:form>
        <apex:commandButton value="Save" action="{!save}"/>
    </apex:form>
</apex:page> 

and controller:

public with sharing class MyController {
    public PageReference save() {
        try {
            insert new Contact[] {
                    new Contact(),
                    new Contact(),
                    new Contact(Phone = '12345678901234567890123456789012345678901234567890'),
                    new Contact(Birthdate = Date.newInstance(1, 1, 0)),
                    new Contact(Birthdate = Date.newInstance(1, 1, 0)),
                    new Contact(AssistantName = 'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ')
                    };
        } catch (DmlException e) {
            ApexPages.addMessages(e);
        }
        return null;
    }
}

produces this result:

So as the plural addMessages method name hints the try/catch/ApexPages.addMessages does a good job of capturing the important information when there are multiple errors.

In terms of efficiency, it is a simple pattern to code correctly so it is efficient in that sense.