Salesforce Future Methods

Introduction

Salesforce Future Methods allow you to run processes asynchronously in the Salesforce environment. This means that the processes are executed in the background at a later time, rather than immediately when they are called. This can be useful for handling tasks that are time-consuming and don’t need to be completed in real-time.

Syntax

The syntax for defining a future method in Salesforce is as follows:

        @future
        public static void methodName() {
            // Method implementation
        }

Salesforce Future Methods Example

Here is an example of how you can use Salesforce Future Methods:

        @future
        public static void updateRecords(List<Id> recordIds) {
            List<Account> accts = [SELECT Id, Name FROM Account WHERE Id IN :recordIds];
            for(Account a : accts) {
                a.Name = 'Updated Name';
            }
            update accts;
        }

Test Classes for Above Example

When writing test classes for methods that use Salesforce Future Methods, you need to ensure that the future method is called in a separate manner. Here is an example of how you can test the above future method:

        @isTest
        private class UpdateRecordsTest {
            @isTest
            static void testUpdateRecords() {
                List<Account> accounts = [SELECT Id FROM Account LIMIT 5];
                
                List<Id> acctIds = new List<Id>();
                for(Account a : accounts) {
                    acctIds.add(a.Id);
                }
                
                Test.startTest();
                YourClass.updateRecords(acctIds);
                Test.stopTest();
                
                List<Account> updatedAccts = [SELECT Name FROM Account WHERE Id IN :acctIds];
                
                for(Account a : updatedAccts) {
                    System.assertEquals('Updated Name', a.Name);
                }
            }
        }

Purpose

The main purpose of using Salesforce Future Methods is to improve the performance of your Salesforce application by offloading long-running tasks to be processed asynchronously. This can help in avoiding governor limits and timeouts that may occur when processing large volumes of data or performing complex operations.

Considerations

• Future methods have some limitations, such as not being able to return a result or take sObjects as arguments.
• There is a limit to the number of future method invocations that can be made per Apex transaction.
• Future methods are queued and executed on a first-come, first-served basis, so there may be a delay in their execution.
• It’s important to handle any potential exceptions that may occur in future methods to prevent them from failing silently.